as-test 1.1.2 → 1.1.4

package/bin/commands/run-core.js

@@ -719,6 +719,8 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
             clean: cleanOutput,
             snapshotEnabled,
             showCoverage,
+            showCoverageAll: Boolean(flags.showCoverageAll),
+            verbose: Boolean(flags.verbose),
             buildTime,
             snapshotSummary,
             coverageSummary,
@@ -1204,6 +1206,10 @@ function normalizeCoverage(value) {
             column: Number(p.column ?? 0),
             type: String(p.type ?? ""),
             executed: Boolean(p.executed),
+            parentHash: String(p.parentHash ?? ""),
+            scopeKind: String(p.scopeKind ?? ""),
+            scopeName: String(p.scopeName ?? ""),
+            depth: Number(p.depth ?? 0),
         };
     })
         .filter((point) => point.file.length > 0);
@@ -1307,12 +1313,18 @@ function isIgnoredCoverageFile(file, coverage) {
     const normalized = file.replace(/\\/g, "/");
     if (!isAllowedCoverageSourceFile(normalized))
         return true;
-    if (normalized.startsWith("node_modules/"))
-        return true;
-    if (normalized.includes("/node_modules/"))
-        return true;
     if (isAssemblyScriptStdlibFile(normalized))
         return true;
+    const classification = classifyCoverageFile(normalized);
+    if (classification.kind == "dependency") {
+        if (coverage.mode != "all" && !coverage.dependencies.length)
+            return true;
+        if (coverage.dependencies.length &&
+            (!classification.packageName ||
+                !coverage.dependencies.includes(classification.packageName))) {
+            return true;
+        }
+    }
     if (!coverage.includeSpecs && normalized.endsWith(".spec.ts"))
         return true;
     if (coverage.include.length &&
@@ -1381,11 +1393,42 @@ function isAssemblyScriptStdlibFile(file) {
         return true;
     return false;
 }
+function classifyCoverageFile(file) {
+    const packageName = resolveCoverageDependencyPackage(file);
+    if (packageName) {
+        return { kind: "dependency", packageName };
+    }
+    return { kind: "project", packageName: null };
+}
+function resolveCoverageDependencyPackage(file) {
+    const normalized = file.replace(/\\/g, "/");
+    const marker = "/node_modules/";
+    const prefixed = normalized.startsWith("node_modules/")
+        ? `/${normalized}`
+        : normalized;
+    const index = prefixed.lastIndexOf(marker);
+    if (index == -1)
+        return null;
+    const after = prefixed.slice(index + marker.length);
+    if (!after.length)
+        return null;
+    const segments = after.split("/").filter(Boolean);
+    if (!segments.length)
+        return null;
+    if (segments[0].startsWith("@")) {
+        if (segments.length < 2)
+            return null;
+        return `${segments[0]}/${segments[1]}`;
+    }
+    return segments[0];
+}
 function resolveCoverageOptions(raw) {
     if (typeof raw == "boolean") {
         return {
             enabled: raw,
+            mode: "project",
             includeSpecs: false,
+            dependencies: [],
             include: [],
             exclude: [],
             ignore: {
@@ -1403,7 +1446,11 @@ function resolveCoverageOptions(raw) {
             : null;
         return {
             enabled: obj.enabled == null ? false : Boolean(obj.enabled),
+            mode: obj.mode == "all" ? "all" : "project",
             includeSpecs: Boolean(obj.includeSpecs),
+            dependencies: Array.isArray(obj.dependencies)
+                ? obj.dependencies.filter((item) => typeof item == "string")
+                : [],
             include: Array.isArray(obj.include)
                 ? obj.include.filter((item) => typeof item == "string")
                 : [],
@@ -1428,7 +1475,9 @@ function resolveCoverageOptions(raw) {
     }
     return {
         enabled: false,
+        mode: "project",
         includeSpecs: false,
+        dependencies: [],
         include: [],
         exclude: [],
         ignore: {
@@ -1475,10 +1524,14 @@ function matchesCoverageTextPattern(value, pattern) {
     return globPatternToRegExp(normalized).test(value);
 }
 function compareCoveragePoints(a, b) {
+    const depthA = a.depth ?? 0;
+    const depthB = b.depth ?? 0;
     if (a.line !== b.line)
         return a.line - b.line;
     if (a.column !== b.column)
         return a.column - b.column;
+    if (depthA !== depthB)
+        return depthA - depthB;
     if (a.type !== b.type)
         return a.type.localeCompare(b.type);
     return a.hash.localeCompare(b.hash);
@@ -2479,3 +2532,9 @@ function resolveReporterFactory(mod) {
     }
     throw new Error(`reporter module must export a factory as "createReporter" or default`);
 }
+export const __coverageInternals = {
+    classifyCoverageFile,
+    resolveCoverageDependencyPackage,
+    isIgnoredCoverageFile,
+    resolveCoverageOptions,
+};

package/bin/commands/run.js

@@ -4,12 +4,14 @@ export async function executeRunCommand(rawArgs, flags, configPath, selectedMode
     const suiteSelectors = deps.resolveSuiteSelectors(rawArgs, "run");
     const listFlags = deps.resolveListFlags(rawArgs, "run");
     const featureToggles = deps.resolveFeatureToggles(rawArgs, "run");
+    const showCoverageMode = deps.resolveShowCoverageMode(rawArgs, "run");
     const runFlags = {
         snapshot: !flags.includes("--no-snapshot"),
         createSnapshots: flags.includes("--create-snapshots"),
         overwriteSnapshots: flags.includes("--overwrite-snapshots"),
         clean: flags.includes("--clean"),
-        showCoverage: flags.includes("--show-coverage"),
+        showCoverage: showCoverageMode != undefined,
+        showCoverageAll: showCoverageMode == "all",
         verbose: flags.includes("--verbose"),
         ...deps.resolveParallelJobs(rawArgs, "run"),
         coverage: featureToggles.coverage,

package/bin/commands/test.js

@@ -8,12 +8,14 @@ export async function executeTestCommand(rawArgs, flags, configPath, selectedMod
         tryAs: featureToggles.tryAs,
         coverage: featureToggles.coverage,
     };
+    const showCoverageMode = deps.resolveShowCoverageMode(rawArgs, "test");
     const runFlags = {
         snapshot: !flags.includes("--no-snapshot"),
         createSnapshots: flags.includes("--create-snapshots"),
         overwriteSnapshots: flags.includes("--overwrite-snapshots"),
         clean: flags.includes("--clean"),
-        showCoverage: flags.includes("--show-coverage"),
+        showCoverage: showCoverageMode != undefined,
+        showCoverageAll: showCoverageMode == "all",
         verbose: flags.includes("--verbose"),
         ...deps.resolveParallelJobs(rawArgs, "test"),
         coverage: featureToggles.coverage,

package/bin/coverage-points.js

@@ -13,7 +13,61 @@ export function describeCoveragePoint(file, line, column, fallbackType) {
             highlightEnd: 0,
         };
     }
-    const declaration = detectCoverageDeclaration(context.visible);
+    const parameter = detectCoverageParameter(context.visible, context.focus, fallbackType);
+    if (parameter) {
+        return {
+            displayType: parameter.type,
+            subjectName: parameter.name,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: parameter.start,
+            highlightEnd: parameter.end,
+        };
+    }
+    const ternary = detectCoverageTernary(context.visible, context.focus, fallbackType);
+    if (ternary) {
+        return {
+            displayType: ternary.type,
+            subjectName: null,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: ternary.start,
+            highlightEnd: ternary.end,
+        };
+    }
+    const ifBranch = detectCoverageIfBranch(context.visible, fallbackType);
+    if (ifBranch) {
+        return {
+            displayType: ifBranch.type,
+            subjectName: null,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: ifBranch.start,
+            highlightEnd: ifBranch.end,
+        };
+    }
+    const assignment = detectCoverageAssignment(context.visible, fallbackType);
+    if (assignment) {
+        return {
+            displayType: assignment.type,
+            subjectName: null,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: assignment.start,
+            highlightEnd: assignment.end,
+        };
+    }
+    const declarationAllowed = fallbackType == "Expression" ||
+        fallbackType == "Block" ||
+        fallbackType == "Function" ||
+        fallbackType == "Method" ||
+        fallbackType == "Constructor" ||
+        fallbackType == "Variable" ||
+        fallbackType == "Property" ||
+        fallbackType == "Call";
+    const declaration = declarationAllowed
+        ? detectCoverageDeclaration(context.visible)
+        : null;
     if (declaration) {
         const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(context.visible, context.focus);
         return {
@@ -25,7 +79,10 @@ export function describeCoveragePoint(file, line, column, fallbackType) {
             highlightEnd,
         };
     }
-    const call = detectCoverageCall(context.visible, context.focus);
+    const callAllowed = fallbackType == "Expression" || fallbackType == "Call";
+    const call = callAllowed
+        ? detectCoverageCall(context.visible, context.focus)
+        : null;
     if (call) {
         return {
             displayType: "Call",
@@ -130,6 +187,147 @@ function detectCoverageDeclaration(visible) {
     }
     return null;
 }
+function detectCoverageParameter(visible, focus, fallbackType) {
+    const inlineParameter = detectCoverageInlineParameter(visible, focus, fallbackType);
+    if (inlineParameter) {
+        return inlineParameter;
+    }
+    const openParen = visible.indexOf("(");
+    const closeParen = visible.lastIndexOf(")");
+    if (openParen == -1 || closeParen == -1 || closeParen <= openParen) {
+        return null;
+    }
+    if (focus <= openParen || focus >= closeParen) {
+        return null;
+    }
+    const params = visible.slice(openParen + 1, closeParen);
+    const matches = [
+        ...params.matchAll(/([A-Za-z_]\w*)\s*:\s*[^,)=]+(?:=\s*[^,)]*)?/g),
+    ];
+    if (!matches.length)
+        return null;
+    for (const match of matches) {
+        const localStart = match.index ?? -1;
+        if (localStart == -1)
+            continue;
+        const localEnd = localStart + match[0].length;
+        const absoluteStart = openParen + 1 + localStart;
+        const absoluteEnd = openParen + 1 + localEnd;
+        if (focus < absoluteStart || focus > absoluteEnd)
+            continue;
+        const name = match[1] ?? null;
+        if (!name)
+            return null;
+        const nameOffset = match[0].indexOf(name);
+        const equalsOffset = match[0].indexOf("=");
+        if (fallbackType == "DefaultValue" && equalsOffset != -1) {
+            const valueStart = absoluteStart + equalsOffset + 1;
+            const valueVisibleStart = skipCoverageWhitespace(visible, valueStart);
+            const [start, end] = resolveCoverageHighlightSpan(visible, Math.max(valueVisibleStart, focus));
+            return {
+                type: "DefaultValue",
+                name,
+                start,
+                end,
+            };
+        }
+        return {
+            type: fallbackType == "Parameter" ? "Parameter" : "Property",
+            name,
+            start: absoluteStart + nameOffset,
+            end: absoluteStart + nameOffset + name.length,
+        };
+    }
+    return null;
+}
+function detectCoverageInlineParameter(visible, focus, fallbackType) {
+    const match = visible.match(/^([A-Za-z_]\w*)\s*:\s*[^=,]+(?:=\s*[^,]+)?[,]?$/);
+    if (!match)
+        return null;
+    const name = match[1] ?? null;
+    if (!name)
+        return null;
+    const nameStart = visible.indexOf(name);
+    const nameEnd = nameStart + name.length;
+    const equalsIndex = visible.indexOf("=");
+    if (fallbackType == "DefaultValue" && equalsIndex != -1) {
+        const valueStart = skipCoverageWhitespace(visible, equalsIndex + 1);
+        const [start, end] = resolveCoverageHighlightSpan(visible, Math.max(valueStart, focus));
+        return {
+            type: "DefaultValue",
+            name,
+            start,
+            end,
+        };
+    }
+    return {
+        type: fallbackType == "Parameter" ? "Parameter" : "Property",
+        name,
+        start: nameStart,
+        end: nameEnd,
+    };
+}
+function detectCoverageTernary(visible, focus, fallbackType) {
+    if (fallbackType != "Ternary" && fallbackType != "LogicalBranch") {
+        return null;
+    }
+    const q = visible.indexOf("?");
+    if (q == -1)
+        return null;
+    if (fallbackType == "LogicalBranch") {
+        const [start, end] = resolveCoverageHighlightSpan(visible, focus);
+        return { type: "LogicalBranch", start, end };
+    }
+    const colon = visible.indexOf(":", q + 1);
+    if (colon == -1) {
+        const [start, end] = resolveCoverageHighlightSpan(visible, focus);
+        return { type: "Ternary", start, end };
+    }
+    const branchStart = focus <= colon ? q + 1 : colon + 1;
+    const normalizedStart = skipCoverageWhitespace(visible, branchStart);
+    const [start, end] = resolveCoverageHighlightSpan(visible, Math.max(normalizedStart, focus));
+    return { type: "Ternary", start, end };
+}
+function detectCoverageIfBranch(visible, fallbackType) {
+    if (fallbackType != "IfBranch")
+        return null;
+    const match = visible.match(/^if\s*\(([^)]*)\)/);
+    if (!match)
+        return null;
+    const full = match[0];
+    const condition = match[1] ?? "";
+    const openParen = full.indexOf("(");
+    const conditionPadding = condition.length
+        ? condition.length - condition.trimStart().length
+        : 0;
+    const conditionStart = openParen == -1 ? -1 : openParen + 1 + conditionPadding;
+    if (conditionStart == -1 || !condition.length) {
+        return { type: "IfBranch", start: 0, end: full.length };
+    }
+    return {
+        type: "IfBranch",
+        start: conditionStart,
+        end: conditionStart + condition.length,
+    };
+}
+function detectCoverageAssignment(visible, fallbackType) {
+    if (fallbackType != "Assignment")
+        return null;
+    const match = visible.match(/([A-Za-z_]\w*(?:\.[A-Za-z_]\w*|\[[^\]]+\])?)\s*(=|\+=|-=|\*=|\*\*=|\/=|%=|<<=|>>=|>>>=|&=|\|=|\^=)/);
+    if (!match)
+        return null;
+    const full = match[0];
+    const lhs = match[1] ?? "";
+    const operator = match[2] ?? "=";
+    const fullStart = visible.indexOf(full);
+    const lhsStart = fullStart + full.indexOf(lhs);
+    const operatorStart = fullStart + full.lastIndexOf(operator);
+    return {
+        type: "Assignment",
+        start: lhsStart,
+        end: operatorStart + operator.length,
+    };
+}
 function detectCoverageCall(visible, focus) {
     const matches = [...visible.matchAll(/\b([A-Za-z_]\w*)(?:<[^>()]+>)?\s*\(/g)];
     if (!matches.length)
@@ -171,3 +369,10 @@ function detectCoverageCall(visible, focus) {
 function isCoverageBoundary(ch) {
     return /[\s()[\]{}.,;:+\-*/%&|^!?=<>]/.test(ch);
 }
+function skipCoverageWhitespace(visible, index) {
+    let current = Math.max(0, Math.min(visible.length - 1, index));
+    while (current < visible.length - 1 && /\s/.test(visible.charAt(current))) {
+        current++;
+    }
+    return current;
+}

package/bin/index.js

@@ -78,6 +78,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveParallelJobs,
                 resolveBrowserOverride,
                 resolveReporterOverride,
+                resolveShowCoverageMode,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runRuntimeModes,
@@ -96,6 +97,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveParallelJobs,
                 resolveBrowserOverride,
                 resolveReporterOverride,
+                resolveShowCoverageMode,
                 resolveFuzzOverrides,
                 resolveExecutionModes,
                 listExecutionPlan,
@@ -277,7 +279,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --create-snapshots       Create missing snapshot entries\n");
         process.stdout.write("  --overwrite-snapshots    Overwrite existing snapshot entries on mismatch\n");
         process.stdout.write("  --no-snapshot            Disable snapshot assertions for this run\n");
-        process.stdout.write("  --show-coverage          Print uncovered coverage point details\n");
+        process.stdout.write("  --show-coverage[=all]    Print uncovered coverage point details; use =all to expand nested gaps\n");
         process.stdout.write("  --suite <name[,name...]> Filter results to matching suite names or suite slug paths\n");
         process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
         process.stdout.write("  --enable <feature>       Enable feature (coverage|try-as)\n");
@@ -305,7 +307,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --create-snapshots       Create missing snapshot entries\n");
         process.stdout.write("  --overwrite-snapshots    Overwrite existing snapshot entries on mismatch\n");
         process.stdout.write("  --no-snapshot            Disable snapshot assertions for this run\n");
-        process.stdout.write("  --show-coverage          Print uncovered coverage point details\n");
+        process.stdout.write("  --show-coverage[=all]    Print uncovered coverage point details; use =all to expand nested gaps\n");
         process.stdout.write("  --suite <name[,name...]> Filter results to matching suite names or suite slug paths\n");
         process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
         process.stdout.write("  --enable <feature>       Enable feature (coverage|try-as)\n");
@@ -462,8 +464,15 @@ function resolveCommandArgs(rawArgs, command) {
             arg == "--build-jobs" ||
             arg == "--run-jobs" ||
             arg == "--browser" ||
+            arg == "--show-coverage" ||
             arg == "--fuzz-runs" ||
             arg == "--fuzz-seed") {
+            if (arg == "--show-coverage") {
+                const next = rawArgs[i + 1];
+                if (next == "all")
+                    i++;
+                continue;
+            }
             i++;
             continue;
         }
@@ -476,6 +485,7 @@ function resolveCommandArgs(rawArgs, command) {
             arg.startsWith("--build-jobs=") ||
             arg.startsWith("--run-jobs=") ||
             arg.startsWith("--browser=") ||
+            arg.startsWith("--show-coverage=") ||
             arg.startsWith("--fuzz-runs=") ||
             arg.startsWith("--fuzz-seed=")) {
             continue;
@@ -762,6 +772,34 @@ function resolveReporterOverride(rawArgs, command) {
     }
     return undefined;
 }
+function resolveShowCoverageMode(rawArgs, command) {
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        if (arg == "--show-coverage") {
+            const next = rawArgs[i + 1];
+            if (next == "all")
+                return "all";
+            return "collapsed";
+        }
+        if (arg.startsWith("--show-coverage=")) {
+            const value = arg.slice("--show-coverage=".length).trim();
+            if (!value.length) {
+                throw new Error("--show-coverage requires a value when using =");
+            }
+            if (value != "all") {
+                throw new Error(`--show-coverage only supports "all" when given a value`);
+            }
+            return "all";
+        }
+    }
+    return undefined;
+}
 function resolveJobs(rawArgs, command) {
     let seenCommand = false;
     let parallel = false;
@@ -1140,6 +1178,8 @@ async function runTestSequential(runFlags, configPath, selectors, suiteSelectors
             clean: runFlags.clean,
             snapshotEnabled,
             showCoverage: runFlags.showCoverage,
+            showCoverageAll: runFlags.showCoverageAll,
+            verbose: runFlags.verbose,
             buildTime: getMergedIntervalDuration(buildIntervals),
             snapshotSummary: summary.snapshotSummary,
             coverageSummary: summary.coverageSummary,
@@ -1372,6 +1412,8 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, suiteSelectors,
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: 0,
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1435,6 +1477,8 @@ async function runTestModes(runFlags, configPath, selectors, suiteSelectors, fuz
                     clean: runFlags.clean,
                     snapshotEnabled: effectiveRunFlags.snapshot !== false,
                     showCoverage: effectiveRunFlags.showCoverage,
+                    showCoverageAll: effectiveRunFlags.showCoverageAll,
+                    verbose: effectiveRunFlags.verbose,
                     buildTime: modeResult.summary.buildTime +
                         getMergedIntervalDuration(collectFuzzBuildIntervals(fuzzResults)),
                     snapshotSummary: modeResult.summary.snapshotSummary,
@@ -1572,6 +1616,8 @@ async function runTestMatrix(runFlags, configPath, selectors, suiteSelectors, fu
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1664,6 +1710,8 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, suiteSe
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: 0,
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1778,6 +1826,8 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, suiteSe
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1880,6 +1930,8 @@ async function runTestSingleParallel(runFlags, configPath, selectors, suiteSelec
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -2013,6 +2065,8 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,