# core/loaders/coverage.loader.ts

> 99 lines of code and 25 definitions.

Tree: GovLab Quality
Language: typescript
Layer: infrastructure
Canonical: https://banes-lab.com/anatomy/quality#file-quality-core-loaders-coverage-loader-ts
Source text: https://banes-lab.com/source/quality/core/loaders/coverage.loader.ts.txt

Listed in [core/loaders](https://banes-lab.com/api/source/quality/core/loaders.md), after [core/loaders/config.loader.ts](https://banes-lab.com/source/quality/core/loaders/config.loader.ts.md) and before [core/loaders/dependency.loader.ts](https://banes-lab.com/source/quality/core/loaders/dependency.loader.ts.md).

## Definitions

- `collectTests` (lexical_declaration, line 15)
- `targetsOf` (lexical_declaration, line 43)
- `appendText` (lexical_declaration, line 69)
- `ownersOf` (lexical_declaration, line 64)
- `packageIndexFor` (lexical_declaration, line 73, exported)
- `centralIndexFor` (lexical_declaration, line 89, exported)
- `packageTarget` (lexical_declaration, line 32)
- `UNTRAVERSED` (lexical_declaration, line 9)
- `TEST_MARKER` (lexical_declaration, line 10)
- `PACKAGE_INDEX_CACHE` (lexical_declaration, line 11)
- `CENTRAL_INDEX_CACHE` (lexical_declaration, line 12)
- `NO_PACKAGE_NAMES` (lexical_declaration, line 13)
- `found` (lexical_declaration, line 16)
- `full` (lexical_declaration, line 18)
- `subpath` (lexical_declaration, line 39)
- `targets` (lexical_declaration, line 44)
- `resolved` (lexical_declaration, line 47)
- `pkg` (lexical_declaration, line 48)
- `target` (lexical_declaration, line 55)
- `own` (lexical_declaration, line 65)
- `key` (lexical_declaration, line 90, exported)
- `cached` (lexical_declaration, line 91, exported)
- `byPackage` (lexical_declaration, line 95, exported)
- `byName` (lexical_declaration, line 97, exported)
- `text` (lexical_declaration, line 99, exported)

## Contained in

- [core/loaders](https://banes-lab.com/anatomy/quality/folder-quality-core-loaders.md)

## Uses

- [core/converters/filename.converter.ts](https://banes-lab.com/source/quality/core/converters/filename.converter.ts.md)
- [core/loaders/source.loader.ts](https://banes-lab.com/source/quality/core/loaders/source.loader.ts.md)
- [core/parsers/specifier.parser.ts](https://banes-lab.com/source/quality/core/parsers/specifier.parser.ts.md)
- [core/resolvers/package.resolver.ts](https://banes-lab.com/source/quality/core/resolvers/package.resolver.ts.md)

## Linked from

- [core/converters](https://banes-lab.com/anatomy/quality/folder-quality-core-converters.md)
- [core/loaders](https://banes-lab.com/anatomy/quality/folder-quality-core-loaders.md)
- [core/parsers](https://banes-lab.com/anatomy/quality/folder-quality-core-parsers.md)
- [core/resolvers](https://banes-lab.com/anatomy/quality/folder-quality-core-resolvers.md)

## Source

```typescript
import { dirOf, forwardSlashed } from "#core/converters/filename.converter";
import { readFileSafe, safeReaddir } from "#core/loaders/source.loader";
import { findPackageRoot } from "#core/resolvers/package.resolver";
import fs from "node:fs";
import { packageNameIndex } from "#core/loaders/package.loader";
import path from "node:path";
import { specifiersIn } from "#core/parsers/specifier.parser";

const UNTRAVERSED = new Set(["node_modules", ".git"]);
const TEST_MARKER = ".test.";
const PACKAGE_INDEX_CACHE = new Map<string, Map<string, string>>();
const CENTRAL_INDEX_CACHE = new Map<string, Map<string, string>>();
const NO_PACKAGE_NAMES = new Map<string, string>();

const collectTests = function collectTests(dir: string): string[] {
    const found: string[] = [];
    for (const entry of safeReaddir(dir)) {
        const full = path.join(dir, entry.name);
        if (entry.isDirectory()) {
            if (!UNTRAVERSED.has(entry.name)) {
                found.push(...collectTests(full));
            }
            continue;
        }
        if (entry.name.includes(TEST_MARKER)) {
            found.push(full);
        }
    }
    return found;
};

const packageTarget = function packageTarget(specifier: string, name: string, dir: string): string | null {
    if (specifier === name) {
        return dir;
    }
    if (!specifier.startsWith(`${name}/`)) {
        return null;
    }
    const subpath = forwardSlashed(path.join(dir, specifier.slice(name.length + 1)));
    return findPackageRoot(dirOf(subpath)) ?? dir;
};

const targetsOf = function targetsOf(file: string, text: string, byName: Map<string, string>): Set<string> {
    const targets = new Set<string>();
    for (const specifier of specifiersIn(text)) {
        if (specifier.startsWith(".")) {
            const resolved = forwardSlashed(path.resolve(dirOf(file), specifier));
            const pkg = findPackageRoot(dirOf(resolved));
            if (pkg !== null) {
                targets.add(pkg);
            }
            continue;
        }
        for (const [name, dir] of byName) {
            const target = packageTarget(specifier, name, dir);
            if (target !== null) {
                targets.add(target);
            }
        }
    }
    return targets;
};

const ownersOf = function ownersOf(file: string, text: string): Set<string> {
    const own = findPackageRoot(dirOf(file));
    return new Set([...(own === null ? [] : [own]), ...targetsOf(file, text, NO_PACKAGE_NAMES)]);
};

const appendText = function appendText(index: Map<string, string>, pkg: string, text: string): void {
    index.set(pkg, `${index.get(pkg) ?? ""}\n${text}`);
};

export const packageIndexFor = function packageIndexFor(rootAbs: string): Map<string, string> {
    const cached = PACKAGE_INDEX_CACHE.get(rootAbs);
    if (cached) {
        return cached;
    }
    const byPackage = new Map<string, string>();
    for (const file of collectTests(rootAbs)) {
        const text = readFileSafe(file);
        for (const pkg of ownersOf(forwardSlashed(file), text)) {
            appendText(byPackage, pkg, text);
        }
    }
    PACKAGE_INDEX_CACHE.set(rootAbs, byPackage);
    return byPackage;
};

export const centralIndexFor = function centralIndexFor(testRootAbs: string, rootAbs: string): Map<string, string> {
    const key = `${testRootAbs}|${rootAbs}`;
    const cached = CENTRAL_INDEX_CACHE.get(key);
    if (cached) {
        return cached;
    }
    const byPackage = new Map<string, string>();
    if (fs.existsSync(testRootAbs)) {
        const byName = packageNameIndex(rootAbs);
        for (const file of collectTests(testRootAbs)) {
            const text = readFileSafe(file);
            for (const target of targetsOf(forwardSlashed(file), text, byName)) {
                appendText(byPackage, target, text);
            }
        }
    }
    CENTRAL_INDEX_CACHE.set(key, byPackage);
    return byPackage;
};
```