# core/loaders/coverage.loader.ts

> 40 lines of code and 11 definitions.

Tree: Build tree
Language: typescript
Layer: infrastructure
Canonical: https://banes-lab.com/anatomy/build#file-build-core-loaders-coverage-loader-ts
Source text: https://banes-lab.com/assets/sources/source.a22dfa3c8147530a3d2e3d28d24653ce768c34ea9b587810853bd36807871a20.generated.txt

## Definitions

- `isRecord` (lexical_declaration, line 13)
- `isGraph` (lexical_declaration, line 17)
- `graphsOf` (lexical_declaration, line 21)
- `loadModule` (lexical_declaration, line 32)
- `constantsFolder` (lexical_declaration, line 27)
- `container` (lexical_declaration, line 28)
- `loadContentGraphs` (lexical_declaration, line 37, exported)
- `folder` (lexical_declaration, line 38, exported)
- `suffix` (lexical_declaration, line 39, exported)
- `files` (lexical_declaration, line 40, exported)
- `loaded` (lexical_declaration, line 44, exported)

## Source

```typescript
import {
    CONFIGURATION_CONTAINER,
    CONSTANTS_CONCERN,
    GRAPH_EXPORT_SUFFIX,
} from "#configuration/constants/coverage.constants";
import { absolutePath, relativePath } from "@ssot/paths";
import { concernSuffix, folderFor } from "@ssot/govlab/shared/manifests/taxonomy.manifest.ts";
import type { ContentGraph } from "#types/coverage.types";
import { containerPath } from "@ssot/govlab/shared/resolvers/container.resolver.ts";
import { pathToFileURL } from "node:url";
import { readdirSync } from "node:fs";

const isRecord = function isRecord(value: unknown): value is Record<string, unknown> {
    return typeof value === "object" && value !== null;
};

const isGraph = function isGraph(value: unknown): value is ContentGraph {
    return isRecord(value) && typeof value["page"] === "string" && isRecord(value["sections"]);
};

const graphsOf = function graphsOf(module: Record<string, unknown>): ContentGraph[] {
    return Object.entries(module).flatMap(([name, value]) =>
        name.endsWith(GRAPH_EXPORT_SUFFIX) && isGraph(value) ? [value] : [],
    );
};

const constantsFolder = function constantsFolder(): string {
    const container = containerPath(CONFIGURATION_CONTAINER, relativePath("app.member"));
    return absolutePath("app.root", container, folderFor(CONSTANTS_CONCERN) ?? "");
};

const loadModule = async function loadModule(file: string): Promise<ContentGraph[]> {
    const loaded: unknown = await import(pathToFileURL(file).href);
    return isRecord(loaded) ? graphsOf(loaded) : [];
};

export const loadContentGraphs = async function loadContentGraphs(): Promise<ContentGraph[]> {
    const folder = constantsFolder();
    const suffix = concernSuffix(CONSTANTS_CONCERN);
    const files = readdirSync(folder)
        .filter((name) => name.endsWith(suffix))
        .sort((a, b) => a.localeCompare(b))
        .map((name) => `${folder}/${name}`);
    const loaded = await Promise.all(files.map(loadModule));
    return loaded.flat();
};
```