# core/loaders/coordination.loader.ts

> 48 lines of code and 10 definitions.

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

## Definitions

- `shippedEntries` (lexical_declaration, line 23, exported)
- `filesUnder` (lexical_declaration, line 28)
- `isText` (lexical_declaration, line 11)
- `listedFiles` (lexical_declaration, line 15)
- `packageFiles` (lexical_declaration, line 35, exported)
- `listed` (lexical_declaration, line 19)
- `parsed` (lexical_declaration, line 24, exported)
- `populatedFolders` (lexical_declaration, line 41, exported)
- `path` (lexical_declaration, line 43, exported)
- `packagePath` (lexical_declaration, line 53, exported)

## Source

```typescript
import {
    BORN_EMPTY_FOLDERS,
    KEEP_FILE,
    SHIP_LIST_KEY,
    SHIP_MANIFEST,
    TEXT_EXTENSIONS,
} from "#configuration/constants/coordination.constants";
import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
import { join, relative, sep } from "node:path";

const isText = function isText(name: string): boolean {
    return TEXT_EXTENSIONS.some((extension) => name.endsWith(extension));
};

const listedFiles = function listedFiles(parsed: unknown): string[] {
    if (typeof parsed !== "object" || parsed === null || !(SHIP_LIST_KEY in parsed)) {
        return [];
    }
    const listed: unknown = parsed[SHIP_LIST_KEY];
    return Array.isArray(listed) ? listed.filter((entry): entry is string => typeof entry === "string") : [];
};

export const shippedEntries = function shippedEntries(root: string): string[] {
    const parsed: unknown = JSON.parse(readFileSync(join(root, SHIP_MANIFEST), "utf8"));
    return [SHIP_MANIFEST, ...listedFiles(parsed)].filter((entry) => existsSync(join(root, entry)));
};

const filesUnder = function filesUnder(path: string): string[] {
    if (!statSync(path).isDirectory()) {
        return isText(path) ? [path] : [];
    }
    return readdirSync(path).flatMap((name) => filesUnder(join(path, name)));
};

export const packageFiles = function packageFiles(root: string): string[] {
    return shippedEntries(root)
        .flatMap((entry) => filesUnder(join(root, entry)))
        .sort((a, b) => a.localeCompare(b));
};

export const populatedFolders = function populatedFolders(root: string): string[] {
    return BORN_EMPTY_FOLDERS.flatMap((folder) => {
        const path = join(root, folder);
        if (!existsSync(path)) {
            return [];
        }
        return readdirSync(path)
            .filter((name) => name !== KEEP_FILE)
            .map((name) => `${folder}/${name}`);
    });
};

export const packagePath = function packagePath(root: string, file: string): string {
    return relative(root, file).split(sep).join("/");
};
```