miniread 1.0.0 → 1.1.0

package/dist/scripts/evaluate/transform-manifest.js

@@ -12,7 +12,7 @@ const average = (values) => {
     return total / values.length;
 };
 export const updateTransformManifestFromEvaluation = async (options) => {
-    const { manifestPath, baselineTransforms, testTransforms, reductionRatios, transformRegistry, } = options;
+    const { manifestPath, baselineTransforms, testTransforms, reductionRatios } = options;
     try {
         await fs.access(manifestPath);
     }
@@ -26,34 +26,10 @@ export const updateTransformManifestFromEvaluation = async (options) => {
     const existingIds = new Set(manifest.transforms.map((t) => t.id));
     const baselineIds = normalizeTransformIds(baselineTransforms);
     const testIds = normalizeTransformIds(testTransforms);
-    const idsToEnsure = new Set([...baselineIds, ...testIds]);
-    idsToEnsure.delete("none");
-    let maxIteration = 0;
-    for (const entry of manifest.transforms) {
-        maxIteration = Math.max(maxIteration, entry.iteration);
-    }
-    let nextIteration = maxIteration + 1;
+    const idsToUpdate = new Set([...baselineIds, ...testIds]);
+    idsToUpdate.delete("none");
+    const missingIds = [...idsToUpdate].filter((id) => !existingIds.has(id));
     let updated = false;
-    for (const transformId of idsToEnsure) {
-        if (existingIds.has(transformId))
-            continue;
-        const transform = transformRegistry[transformId];
-        const description = transform?.description ?? `Auto-added by evaluation: ${transformId}`;
-        const scope = transform?.scope ?? "file";
-        const parallelizable = transform?.parallelizable ?? true;
-        manifest.transforms.push({
-            id: transformId,
-            description,
-            iteration: nextIteration++,
-            scope,
-            parallelizable,
-            diffReductionImpact: 0,
-            enabledByDefault: false,
-            notes: "Auto-added by evaluation script.",
-        });
-        existingIds.add(transformId);
-        updated = true;
-    }
     const isBaselineNone = baselineIds.length === 0 ||
         (baselineTransforms.length === 1 && baselineTransforms[0] === "none");
     if (isBaselineNone && testIds.length === 1) {
@@ -63,10 +39,6 @@ export const updateTransformManifestFromEvaluation = async (options) => {
             const entry = manifest.transforms.find((t) => t.id === transformId);
             if (entry && entry.diffReductionImpact !== measuredImpact) {
                 entry.diffReductionImpact = measuredImpact;
-                const measurementNote = `Measured with baseline none: ${(measuredImpact * 100).toFixed(2)}%.`;
-                entry.notes = entry.notes
-                    ? `${entry.notes} ${measurementNote}`
-                    : measurementNote;
                 updated = true;
             }
         }
@@ -92,11 +64,20 @@ export const updateTransformManifestFromEvaluation = async (options) => {
         }
     }
     if (!updated) {
+        const missingMessage = missingIds.length > 0
+            ? ` Missing transform entries: ${missingIds.join(", ")}. Add them to transform-manifest.json manually.`
+            : "";
         return {
             updated: false,
-            message: "transform-manifest.json already up to date",
+            message: `transform-manifest.json already up to date.${missingMessage}`,
         };
     }
     await writeJsonFileAtomic(manifestPath, manifest, { overwrite: true });
-    return { updated: true, message: "Updated transform-manifest.json" };
+    const missingMessage = missingIds.length > 0
+        ? ` Missing transform entries: ${missingIds.join(", ")}. Add them to transform-manifest.json manually.`
+        : "";
+    return {
+        updated: true,
+        message: `Updated transform-manifest.json.${missingMessage}`,
+    };
 };

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.d.ts

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

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.js

@@ -0,0 +1,91 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const isSupportedParent = (path) => {
+    return path.parentPath.isBlockStatement() || path.parentPath.isSwitchCase();
+};
+const getSequenceExpressions = (node) => {
+    const argument = node.argument;
+    if (!argument)
+        return;
+    if (argument.type !== "SequenceExpression")
+        return;
+    if (argument.expressions.length < 2)
+        return;
+    return argument.expressions;
+};
+const createExpressionStatement = (expression) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.expressionStatement(expression);
+};
+const createReturnStatement = (expression) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.returnStatement(expression);
+};
+const isDirectiveProloguePosition = (path) => {
+    if (!path.parentPath.isBlockStatement())
+        return false;
+    const siblings = path.parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const expandReturnSequenceTransform = {
+    id: "expand-return-sequence",
+    description: "Expands return sequences like `return a(), b();`",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                ReturnStatement(path) {
+                    nodesVisited++;
+                    if (!isSupportedParent(path))
+                        return;
+                    const expressions = getSequenceExpressions(path.node);
+                    if (!expressions)
+                        return;
+                    const leadingExpressions = expressions.slice(0, -1);
+                    const lastExpression = expressions.at(-1);
+                    if (!lastExpression)
+                        return;
+                    const firstExpression = leadingExpressions[0];
+                    if (firstExpression?.type === "StringLiteral" &&
+                        isDirectiveProloguePosition(path)) {
+                        return;
+                    }
+                    const statements = leadingExpressions.map((expression) => createExpressionStatement(
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    t.cloneNode(expression, true)));
+                    statements.push(createReturnStatement(
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                    t.cloneNode(lastExpression, true)));
+                    path.replaceWithMultiple(statements);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/expand-sequence-expressions/expand-expression-statement-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ExpressionStatement } from "@babel/types";
+export declare const tryExpandExpressionStatementSequence: (path: NodePath<ExpressionStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions/expand-expression-statement-sequence.js

@@ -0,0 +1,57 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const isSupportedStatementContainer = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    return (parentPath.isProgram() ||
+        parentPath.isBlockStatement() ||
+        parentPath.isSwitchCase());
+};
+const isDirectiveProloguePosition = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    if (!parentPath.isProgram() && !parentPath.isBlockStatement())
+        return false;
+    const siblings = parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandExpressionStatementSequence = (path) => {
+    if (!isSupportedStatementContainer(path))
+        return false;
+    const expression = path.node.expression;
+    if (expression.type !== "SequenceExpression")
+        return false;
+    if (expression.expressions.length < 2)
+        return false;
+    const firstExpression = expression.expressions[0];
+    if (firstExpression?.type === "StringLiteral" &&
+        isDirectiveProloguePosition(path)) {
+        return false;
+    }
+    const statements = expression.expressions.map((expr) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.expressionStatement(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        t.cloneNode(expr, true));
+    });
+    path.replaceWithMultiple(statements);
+    return true;
+};

package/dist/transforms/expand-sequence-expressions/expand-sequence-expressions-transform.d.ts

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

package/dist/transforms/expand-sequence-expressions/expand-sequence-expressions-transform.js

@@ -0,0 +1,34 @@
+import { createRequire } from "node:module";
+import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
+import { tryExpandVariableDeclarationSequenceInitializers } from "./expand-variable-declaration-sequence.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const expandSequenceExpressionsTransform = {
+    id: "expand-sequence-expressions",
+    description: "Expands comma operator sequences in statements and variable initializers",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                ExpressionStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandExpressionStatementSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+                VariableDeclaration(path) {
+                    nodesVisited++;
+                    if (!tryExpandVariableDeclarationSequenceInitializers(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/expand-sequence-expressions/expand-variable-declaration-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { VariableDeclaration } from "@babel/types";
+export declare const tryExpandVariableDeclarationSequenceInitializers: (path: NodePath<VariableDeclaration>) => boolean;

package/dist/transforms/expand-sequence-expressions/expand-variable-declaration-sequence.js

@@ -0,0 +1,93 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const createExpressionStatement = (expression) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.expressionStatement(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.cloneNode(expression, true));
+};
+const createVariableDeclarationStatement = (kind, declarator) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.variableDeclaration(kind, [declarator]);
+};
+const createVariableDeclarator = (id, init) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.variableDeclarator(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.cloneNode(id, true), init
+        ? // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            t.cloneNode(init, true)
+        : undefined);
+};
+const isSupportedStatementContainer = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    return (parentPath.isProgram() ||
+        parentPath.isBlockStatement() ||
+        parentPath.isSwitchCase());
+};
+const isDirectiveProloguePosition = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    if (!parentPath.isProgram() && !parentPath.isBlockStatement())
+        return false;
+    const siblings = parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandVariableDeclarationSequenceInitializers = (path) => {
+    if (!isSupportedStatementContainer(path))
+        return false;
+    if (path.node.kind !== "var" && path.node.declarations.length > 1) {
+        return false;
+    }
+    if (isDirectiveProloguePosition(path)) {
+        const wouldInsertStringLiteral = path.node.declarations.some((declarator) => declarator.init?.type === "SequenceExpression" &&
+            declarator.init.expressions[0]?.type === "StringLiteral");
+        if (wouldInsertStringLiteral)
+            return false;
+    }
+    const hasAnySequence = path.node.declarations.some((declarator) => declarator.init?.type === "SequenceExpression" &&
+        declarator.init.expressions.length >= 2);
+    if (!hasAnySequence)
+        return false;
+    const kind = path.node.kind;
+    const statements = [];
+    for (const declarator of path.node.declarations) {
+        const init = declarator.init;
+        if (init?.type !== "SequenceExpression") {
+            statements.push(createVariableDeclarationStatement(kind, declarator));
+            continue;
+        }
+        const leadingExpressions = init.expressions.slice(0, -1);
+        const lastExpression = init.expressions.at(-1);
+        if (!lastExpression) {
+            statements.push(createVariableDeclarationStatement(kind, declarator));
+            continue;
+        }
+        for (const expression of leadingExpressions) {
+            statements.push(createExpressionStatement(expression));
+        }
+        const newDeclarator = createVariableDeclarator(declarator.id, lastExpression);
+        statements.push(createVariableDeclarationStatement(kind, newDeclarator));
+    }
+    path.replaceWithMultiple(statements);
+    return true;
+};

package/dist/transforms/expand-sequence-expressions-v2/expand-expression-statement-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ExpressionStatement } from "@babel/types";
+export declare const tryExpandExpressionStatementSequence: (path: NodePath<ExpressionStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions-v2/expand-expression-statement-sequence.js

@@ -0,0 +1,55 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const isSupportedStatementContainer = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    return (parentPath.isProgram() ||
+        parentPath.isBlockStatement() ||
+        parentPath.isSwitchCase());
+};
+const isDirectiveProloguePosition = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath.isProgram() && !parentPath.isBlockStatement())
+        return false;
+    const siblings = parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandExpressionStatementSequence = (path) => {
+    if (!isSupportedStatementContainer(path))
+        return false;
+    const expression = path.node.expression;
+    if (expression.type !== "SequenceExpression")
+        return false;
+    if (expression.expressions.length < 2)
+        return false;
+    const firstExpression = expression.expressions[0];
+    if (firstExpression?.type === "StringLiteral" &&
+        isDirectiveProloguePosition(path)) {
+        return false;
+    }
+    const statements = expression.expressions.map((expr) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.expressionStatement(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        t.cloneNode(expr, true));
+    });
+    path.replaceWithMultiple(statements);
+    return true;
+};

package/dist/transforms/expand-sequence-expressions-v2/expand-return-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ReturnStatement } from "@babel/types";
+export declare const tryExpandReturnSequence: (path: NodePath<ReturnStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions-v2/expand-return-sequence.js

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const canReplaceWithMultiple = (path) => {
+    return path.parentPath.isBlockStatement() || path.parentPath.isSwitchCase();
+};
+const canWrapInBlock = (path) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isIfStatement() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        return true;
+    }
+    if ((parentPath.isForStatement() ||
+        parentPath.isForInStatement() ||
+        parentPath.isForOfStatement() ||
+        parentPath.isWhileStatement() ||
+        parentPath.isDoWhileStatement() ||
+        parentPath.isWithStatement()) &&
+        path.key === "body") {
+        return true;
+    }
+    return false;
+};
+const replaceReturnWithStatements = (path, statements) => {
+    if (canReplaceWithMultiple(path)) {
+        path.replaceWithMultiple(statements);
+        return true;
+    }
+    if (canWrapInBlock(path)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        path.replaceWith(t.blockStatement(statements));
+        return true;
+    }
+    return false;
+};
+const isDirectiveProloguePosition = (path) => {
+    if (!path.parentPath.isBlockStatement())
+        return false;
+    const siblings = path.parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandReturnSequence = (path) => {
+    if (!canReplaceWithMultiple(path) && !canWrapInBlock(path))
+        return false;
+    const argument = path.node.argument;
+    if (!argument)
+        return false;
+    if (argument.type !== "SequenceExpression")
+        return false;
+    if (argument.expressions.length < 2)
+        return false;
+    const leadingExpressions = argument.expressions.slice(0, -1);
+    const lastExpression = argument.expressions.at(-1);
+    if (!lastExpression)
+        return false;
+    const firstExpression = leadingExpressions[0];
+    if (firstExpression?.type === "StringLiteral" &&
+        isDirectiveProloguePosition(path)) {
+        return false;
+    }
+    const statements = leadingExpressions.map((expression) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.expressionStatement(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        t.cloneNode(expression, true));
+    });
+    statements.push(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.returnStatement(t.cloneNode(lastExpression, true)));
+    return replaceReturnWithStatements(path, statements);
+};

package/dist/transforms/expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.d.ts

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

package/dist/transforms/expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.js

@@ -0,0 +1,41 @@
+import { createRequire } from "node:module";
+import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
+import { tryExpandReturnSequence } from "./expand-return-sequence.js";
+import { tryExpandVariableDeclarationSequenceInitializers } from "./expand-variable-declaration-sequence.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const expandSequenceExpressionsV2Transform = {
+    id: "expand-sequence-expressions-v2",
+    description: "Expands comma operator sequences in returns, statements, and variable initializers",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                ReturnStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandReturnSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+                ExpressionStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandExpressionStatementSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+                VariableDeclaration(path) {
+                    nodesVisited++;
+                    if (!tryExpandVariableDeclarationSequenceInitializers(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/expand-sequence-expressions-v2/expand-variable-declaration-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { VariableDeclaration } from "@babel/types";
+export declare const tryExpandVariableDeclarationSequenceInitializers: (path: NodePath<VariableDeclaration>) => boolean;