miniread 1.17.0 → 1.18.0

package/dist/scripts/snapshot/format-code.d.ts

@@ -0,0 +1 @@
+export declare const formatCode: (code: string) => Promise<string>;

package/dist/scripts/snapshot/format-code.js

@@ -0,0 +1,4 @@
+import * as prettier from "prettier";
+export const formatCode = async (code) => {
+    return prettier.format(code, { parser: "babel" });
+};

package/dist/scripts/snapshot/print-snapshot-diff.d.ts

@@ -0,0 +1,6 @@
+type PrintSnapshotDiffOptions = {
+    expectedContent: string;
+    actualOutput: string;
+};
+export declare const printSnapshotDiff: (options: PrintSnapshotDiffOptions) => void;
+export {};

package/dist/scripts/snapshot/print-snapshot-diff.js

@@ -0,0 +1,26 @@
+export const printSnapshotDiff = (options) => {
+    const { expectedContent, actualOutput } = options;
+    console.log(`\nDiff: expected vs actual`);
+    console.log("---");
+    const expectedLines = expectedContent.split("\n");
+    const actualLines = actualOutput.split("\n");
+    const maxLines = Math.max(expectedLines.length, actualLines.length);
+    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
+        const expectedLine = expectedLines[lineIndex];
+        const actualLine = actualLines[lineIndex];
+        if (expectedLine === actualLine)
+            continue;
+        console.log(`Line ${lineIndex + 1}:`);
+        if (expectedLine !== undefined && actualLine === undefined) {
+            console.log(`  - ${expectedLine}`);
+            continue;
+        }
+        if (expectedLine === undefined && actualLine !== undefined) {
+            console.log(`  + ${actualLine}`);
+            continue;
+        }
+        console.log(`  - ${expectedLine}`);
+        console.log(`  + ${actualLine}`);
+    }
+    console.log("---");
+};

package/dist/scripts/snapshot/resolve-testcase-input.d.ts

@@ -0,0 +1,16 @@
+type ResolveTestcaseInputOptions = {
+    testcase: string;
+};
+type ResolveTestcaseInputValue = {
+    testcaseDirectory: string;
+    basePath: string;
+};
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare const resolveTestcaseInput: (options: ResolveTestcaseInputOptions) => Promise<Result<ResolveTestcaseInputValue>>;
+export {};

package/dist/scripts/snapshot/resolve-testcase-input.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
+export const resolveTestcaseInput = async (options) => {
+    const { testcase } = options;
+    const testcaseDirectory = path.join(TEST_CASES_DIR, testcase);
+    try {
+        const stats = await fs.stat(testcaseDirectory);
+        if (!stats.isDirectory()) {
+            return { ok: false, error: new Error(`${testcase} is not a directory`) };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            error: new Error(`Test case directory not found: test-cases/${testcase}`),
+        };
+    }
+    const basePath = path.join(testcaseDirectory, "base.js");
+    try {
+        await fs.access(basePath);
+    }
+    catch {
+        return {
+            ok: false,
+            error: new Error(`base.js not found in test-cases/${testcase}/`),
+        };
+    }
+    return { ok: true, value: { testcaseDirectory, basePath } };
+};

package/dist/scripts/snapshot/run-snapshot-cli.js

@@ -1,75 +1,39 @@
 import * as fs from "node:fs/promises";
-import { createRequire } from "node:module";
 import path from "node:path";
-import * as prettier from "prettier";
 import packageJson from "../../../package.json" with { type: "json" };
-import { buildProjectGraph } from "../../core/project-graph.js";
-import { transformPresets } from "../../transforms/transform-presets.js";
-import { transformRegistry } from "../../transforms/transform-registry.js";
+import { formatCode } from "./format-code.js";
 import { createSnapshotCommand, } from "./create-snapshot-command.js";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-const generate = require("@babel/generator").default;
-const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
-const formatCode = async (code) => prettier.format(code, { parser: "babel" });
-const runTransform = async (inputPath, transformId) => {
-    const content = await fs.readFile(inputPath, "utf8");
-    // Handle "recommended" as a special case that runs all recommended transforms
-    const transformIds = transformId === "recommended"
-        ? transformPresets.recommended
-        : [transformId];
-    const transforms = transformIds.map((id) => {
-        const transform = transformRegistry[id];
-        if (!transform) {
-            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
-        }
-        return transform;
-    });
-    const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
-    for (const transform of transforms) {
-        await transform.transform({
-            projectGraph,
-            currentFile: undefined,
-            options: {},
-        });
-    }
-    const fileInfo = projectGraph.files.get(inputPath);
-    if (!fileInfo) {
-        return content;
-    }
-    return generate(fileInfo.ast).code;
-};
+import { printSnapshotDiff } from "./print-snapshot-diff.js";
+import { resolveTestcaseInput } from "./resolve-testcase-input.js";
+import { runTestcaseTransform } from "./run-testcase-transform.js";
 export const runSnapshotCli = async (argv) => {
     const program = createSnapshotCommand({ version: packageJson.version });
     program.parse(argv.filter((argument) => argument !== "--"));
     const rawOptions = program.opts();
     const { testcase, transform, expected } = rawOptions;
-    // Validate test case directory exists
-    const testCaseDirectory = path.join(TEST_CASES_DIR, testcase);
-    try {
-        const stats = await fs.stat(testCaseDirectory);
-        if (!stats.isDirectory()) {
-            console.error(`Error: ${testcase} is not a directory`);
+    const resolved = await resolveTestcaseInput({ testcase });
+    if (!resolved.ok) {
+        const message = resolved.error.message;
+        if (message === `${testcase} is not a directory`) {
+            console.error(`Error: ${message}`);
             return 1;
         }
-    }
-    catch {
-        console.error(`Error: Test case directory not found: test-cases/${testcase}`);
-        console.error(`Create it first: mkdir -p test-cases/${testcase}`);
-        return 1;
-    }
-    // Validate base.js exists
-    const basePath = path.join(testCaseDirectory, "base.js");
-    try {
-        await fs.access(basePath);
-    }
-    catch {
-        console.error(`Error: base.js not found in test-cases/${testcase}/`);
-        console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+        if (message.startsWith("Test case directory not found:")) {
+            console.error(`Error: ${message}`);
+            console.error(`Create it first: mkdir -p test-cases/${testcase}`);
+            return 1;
+        }
+        if (message.startsWith("base.js not found in test-cases/")) {
+            console.error(`Error: ${message}`);
+            console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+            return 1;
+        }
+        console.error(`Error: ${message}`);
         return 1;
     }
-    const expectedPath = path.join(testCaseDirectory, `${transform}-expected.js`);
-    const actualPath = path.join(testCaseDirectory, `${transform}.js`);
+    const { testcaseDirectory, basePath } = resolved.value;
+    const expectedPath = path.join(testcaseDirectory, `${transform}-expected.js`);
+    const actualPath = path.join(testcaseDirectory, `${transform}.js`);
     if (expected) {
         // Expected-file workflow
         // Step 1: Check if expected file exists, create from base.js if not
@@ -83,69 +47,53 @@ export const runSnapshotCli = async (argv) => {
             await fs.writeFile(expectedPath, formattedBase);
             console.log(`Created: test-cases/${testcase}/${transform}-expected.js`);
             console.log("Edit this file to match your expected output, then re-run.");
+            // Design phase: allow creating the expected file before the transform exists.
+            // The next run (after implementing the transform) will write the actual output
+            // and compare it against this expected snapshot.
             return 0;
         }
-    }
-    // Common path: Run the transform, format, and write actual output
-    let actualOutput;
-    try {
-        const rawOutput = await runTransform(basePath, transform);
-        actualOutput = await formatCode(rawOutput);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error running transform: ${message}`);
-        return 1;
-    }
-    await fs.writeFile(actualPath, actualOutput);
-    console.log(`Created: test-cases/${testcase}/${transform}.js`);
-    if (!expected) {
-        return 0;
-    }
-    // Step 3: Compare expected vs actual
-    const expectedContent = await fs.readFile(expectedPath, "utf8");
-    if (expectedContent === actualOutput) {
-        // Success! Delete expected file
-        await fs.unlink(expectedPath);
-        console.log(`\nSuccess: Output matches expected.`);
-        console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
-        console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
-        return 0;
-    }
-    // Diff - show the difference
-    console.log(`\nDiff: expected vs actual`);
-    console.log("---");
-    // Simple line-by-line diff output
-    const expectedLines = expectedContent.split("\n");
-    const actualLines = actualOutput.split("\n");
-    const maxLines = Math.max(expectedLines.length, actualLines.length);
-    let hasDiff = false;
-    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
-        const exp = expectedLines[lineIndex];
-        const act = actualLines[lineIndex];
-        if (exp !== act) {
-            hasDiff = true;
-            if (exp !== undefined && act === undefined) {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  - ${exp}`);
-            }
-            else if (exp === undefined && act !== undefined) {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  + ${act}`);
-            }
-            else {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  - ${exp}`);
-                console.log(`  + ${act}`);
-            }
+        const outputResult = await runTestcaseTransform({
+            inputPath: basePath,
+            transformId: transform,
+        });
+        if (!outputResult.ok) {
+            console.error(`Error running transform: ${outputResult.error.message}`);
+            return 1;
+        }
+        const actualOutput = outputResult.value;
+        // Step 2: Write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        // Step 3: Compare expected vs actual
+        const expectedContent = await fs.readFile(expectedPath, "utf8");
+        if (expectedContent === actualOutput) {
+            // Success! Delete expected file
+            await fs.unlink(expectedPath);
+            console.log(`\nSuccess: Output matches expected.`);
+            console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
+            console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
+            return 0;
+        }
+        else {
+            printSnapshotDiff({ expectedContent, actualOutput });
+            console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
+            console.log("Fix the implementation or update the expected file, then re-run.");
+            return 1;
         }
     }
-    if (!hasDiff) {
-        // Shouldn't happen since we already checked equality, but just in case
-        console.log("(no visible differences)");
+    else {
+        const outputResult = await runTestcaseTransform({
+            inputPath: basePath,
+            transformId: transform,
+        });
+        if (!outputResult.ok) {
+            console.error(`Error running transform: ${outputResult.error.message}`);
+            return 1;
+        }
+        const actualOutput = outputResult.value;
+        // Simple mode: just write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        return 0;
     }
-    console.log("---");
-    console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
-    console.log("Fix the implementation or update the expected file, then re-run.");
-    return 1;
 };

package/dist/scripts/snapshot/run-testcase-transform.d.ts

@@ -0,0 +1,13 @@
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+type RunTestcaseTransformOptions = {
+    inputPath: string;
+    transformId: string;
+};
+export declare const runTestcaseTransform: (options: RunTestcaseTransformOptions) => Promise<Result<string>>;
+export {};

package/dist/scripts/snapshot/run-testcase-transform.js

@@ -0,0 +1,46 @@
+import { createRequire } from "node:module";
+import * as fs from "node:fs/promises";
+import { buildProjectGraph } from "../../core/project-graph.js";
+import { transformPresets } from "../../transforms/transform-presets.js";
+import { transformRegistry } from "../../transforms/transform-registry.js";
+import { formatCode } from "./format-code.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const runTransform = async (inputPath, transformId) => {
+    const content = await fs.readFile(inputPath, "utf8");
+    const transformIds = transformId === "recommended"
+        ? transformPresets.recommended
+        : [transformId];
+    const transforms = transformIds.map((id) => {
+        const transform = transformRegistry[id];
+        if (!transform) {
+            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
+        }
+        return transform;
+    });
+    const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
+    for (const transform of transforms) {
+        await transform.transform({
+            projectGraph,
+            currentFile: undefined,
+            options: {},
+        });
+    }
+    const fileInfo = projectGraph.files.get(inputPath);
+    if (!fileInfo)
+        return content;
+    return generate(fileInfo.ast).code;
+};
+export const runTestcaseTransform = async (options) => {
+    const { inputPath, transformId } = options;
+    try {
+        const rawOutput = await runTransform(inputPath, transformId);
+        const output = await formatCode(rawOutput);
+        return { ok: true, value: output };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: new Error(message) };
+    }
+};

package/dist/transforms/simplify-boolean-negations/simplify-boolean-negations-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const simplifyBooleanNegationsTransform: Transform;

package/dist/transforms/simplify-boolean-negations/simplify-boolean-negations-transform.js

@@ -0,0 +1,90 @@
+import { createRequire } from "node:module";
+import { getFilesToProcess } from "../../core/types.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const isInBooleanTestContext = (path) => {
+    let current = path;
+    // A `!!x` node is safe to rewrite as `x` only when its value is consumed
+    // purely for truthiness (control-flow tests and boolean operator chains).
+    // If we encounter any other parent expression before reaching the test
+    // boundary, the expression value is being used (e.g. as a call argument),
+    // and rewriting would be unsafe.
+    for (;;) {
+        const parent = current.parentPath;
+        if (!parent)
+            return false;
+        if ((parent.isIfStatement() ||
+            parent.isWhileStatement() ||
+            parent.isDoWhileStatement() ||
+            parent.isForStatement() ||
+            parent.isConditionalExpression()) &&
+            current.key === "test") {
+            return true;
+        }
+        if (parent.isLogicalExpression()) {
+            if (current.key !== "left" && current.key !== "right")
+                return false;
+            current = parent;
+            continue;
+        }
+        if (parent.isUnaryExpression({ operator: "!" })) {
+            if (current.key !== "argument")
+                return false;
+            current = parent;
+            continue;
+        }
+        if (parent.isSequenceExpression()) {
+            if (current.listKey !== "expressions")
+                return false;
+            const expressions = parent.node.expressions;
+            const lastExpression = expressions.at(-1);
+            if (!lastExpression)
+                return false;
+            if (lastExpression !== current.node)
+                return false;
+            current = parent;
+            continue;
+        }
+        if (parent.isParenthesizedExpression()) {
+            if (current.key !== "expression")
+                return false;
+            current = parent;
+            continue;
+        }
+        return false;
+    }
+};
+export const simplifyBooleanNegationsTransform = {
+    id: "simplify-boolean-negations",
+    description: "Simplifies redundant boolean negations: !true/!false and !!x in control-flow tests",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                UnaryExpression(path) {
+                    nodesVisited++;
+                    if (path.node.operator !== "!")
+                        return;
+                    const argument = path.node.argument;
+                    if (argument.type === "BooleanLiteral") {
+                        path.replaceWith(t.booleanLiteral(!argument.value));
+                        transformationsApplied++;
+                        return;
+                    }
+                    if (argument.type === "UnaryExpression" &&
+                        argument.operator === "!" &&
+                        isInBooleanTestContext(path)) {
+                        path.replaceWith(argument.argument);
+                        transformationsApplied++;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -21,6 +21,7 @@ import { renameThisAliasesTransform } from "./rename-this-aliases/rename-this-al
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { renameUseReferenceGuardsV2Transform } from "./rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
+import { simplifyBooleanNegationsTransform } from "./simplify-boolean-negations/simplify-boolean-negations-transform.js";
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
@@ -46,6 +47,7 @@ export const transformRegistry = {
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
+    [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",

package/transform-manifest.json

@@ -10,6 +10,15 @@
       "evaluatedAt": "2026-01-21T15:01:23.708Z",
       "notes": "Improves readability but does not reduce diffs (boolean literals are already deterministic)"
     },
+    {
+      "id": "simplify-boolean-negations",
+      "description": "Simplifies redundant boolean negations: !true/!false and !!x in control-flow tests",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "notes": "Added manually; improves readability and cleans up `expand-boolean-literals` output."
+    },
     {
       "id": "expand-undefined-literals",
       "description": "Expands void 0 to undefined (when undefined is not shadowed)",