# tools/core/readers/architecture.reader.ts

> 47 lines of code and 19 definitions.

Tree: Coordination tree
Language: typescript
Canonical: https://banes-lab.com/anatomy/coordination#file-coordination-tools-core-readers-architecture-reader-ts
Source text: https://banes-lab.com/assets/sources/source.add01f2b68a56582bbc06b9be99a4c073aa003a962d98d4e9e3f4a37da5854d8.generated.txt

## Definitions

- `idAt` (lexical_declaration, line 16)
- `anchoredId` (lexical_declaration, line 35)
- `isDigit` (lexical_declaration, line 12)
- `occurrences` (lexical_declaration, line 25)
- `idsIn` (lexical_declaration, line 40)
- `PrincipleWalk` (interface_declaration, line 1, exported)
- `RECORD_ANCHOR` (lexical_declaration, line 8)
- `PREFIX` (lexical_declaration, line 10)
- `from` (lexical_declaration, line 17)
- `cursor` (lexical_declaration, line 18)
- `out` (lexical_declaration, line 26)
- `at` (lexical_declaration, line 27)
- `trimmed` (lexical_declaration, line 36)
- `byId` (lexical_declaration, line 46)
- `walkPrinciples` (lexical_declaration, line 50, exported)
- `declared` (lexical_declaration, line 51, exported)
- `cited` (lexical_declaration, line 52, exported)
- `uncited` (lexical_declaration, line 54, exported)
- `dangling` (lexical_declaration, line 55, exported)

## Source

```typescript
export interface PrincipleWalk {
    readonly declared: number;
    readonly cited: number;
    readonly uncited: readonly string[];
    readonly danglingCitations: readonly string[];
}

const RECORD_ANCHOR = "### ";

const PREFIX = "ARC-";

const isDigit = function isDigit(char: string): boolean {
    return char >= "0" && char <= "9";
};

const idAt = function idAt(text: string, at: number): string[] {
    const from = at + PREFIX.length;
    let cursor = from;
    while (cursor < text.length && isDigit(text.charAt(cursor))) {
        cursor += 1;
    }
    return cursor > from ? [text.slice(at, cursor)] : [];
};

const occurrences = function occurrences(text: string): number[] {
    const out: number[] = [];
    let at = text.indexOf(PREFIX);
    while (at !== -1) {
        out.push(at);
        at = text.indexOf(PREFIX, at + PREFIX.length);
    }
    return out;
};

const anchoredId = function anchoredId(line: string): string[] {
    const trimmed = line.trim();
    return trimmed.indexOf(PREFIX) === RECORD_ANCHOR.length ? idAt(trimmed, RECORD_ANCHOR.length) : [];
};

const idsIn = function idsIn(source: string, anchored: boolean): string[] {
    return source
        .split("\n")
        .flatMap((line) => (anchored ? anchoredId(line) : occurrences(line).flatMap((at) => idAt(line, at))));
};

const byId = function byId(left: string, right: string): number {
    return left.localeCompare(right, "en");
};

export const walkPrinciples = function walkPrinciples(catalog: string, citing: readonly string[]): PrincipleWalk {
    const declared = new Set(idsIn(catalog, true));
    const cited = new Set(citing.flatMap((source) => idsIn(source, false)));

    const uncited = [...declared].filter((id) => !cited.has(id)).toSorted(byId);
    const dangling = [...cited].filter((id) => !declared.has(id)).toSorted(byId);

    return { cited: declared.size - uncited.length, danglingCitations: dangling, declared: declared.size, uncited };
};
```