# domain/registries/page.registry.ts

> 44 lines of code and 13 definitions.

Tree: Site tree
Language: typescript
Layer: infrastructure
Canonical: https://banes-lab.com/anatomy/tree#file-domain-registries-page-registry-ts
Source text: https://banes-lab.com/assets/sources/source.ffec2ef28c6e45e83534aea6b489b5cf97213e5d02959139f7ff448b51c6bc19.generated.txt

## Definitions

- `loadedPage` (lexical_declaration, line 27, exported)
- `loadPage` (lexical_declaration, line 31, exported)
- `pages` (lexical_declaration, line 4)
- `loaded` (lexical_declaration, line 5)
- `pending` (lexical_declaration, line 6)
- `registerPage` (lexical_declaration, line 8, exported)
- `getPage` (lexical_declaration, line 12, exported)
- `listPages` (lexical_declaration, line 16, exported)
- `registeredPages` (lexical_declaration, line 23, exported)
- `held` (lexical_declaration, line 32, exported)
- `entry` (lexical_declaration, line 36, exported)
- `inFlight` (lexical_declaration, line 40, exported)
- `loading` (lexical_declaration, line 44, exported)

## Used by

- [presentation/widgets/tab.widget.ts](https://banes-lab.com/source/tree/presentation/widgets/tab.widget.ts.md)
- [runtime/coordinators/route.coordinator.ts](https://banes-lab.com/source/tree/runtime/coordinators/route.coordinator.ts.md)

## Source

```typescript
import type { PageDefinition, PageEntry } from "#types/page.types";
import { createRegistry } from "#domain/registries/base.registry";

const pages = createRegistry<PageEntry>();
const loaded = new Map<string, PageDefinition>();
const pending = new Map<string, Promise<PageDefinition | undefined>>();

export const registerPage = function registerPage(page: PageEntry): void {
    pages.register(page);
};

export const getPage = function getPage(id: string): PageEntry | undefined {
    return pages.byId(id);
};

export const listPages = function listPages(): readonly PageEntry[] {
    return pages
        .all()
        .filter((page) => page.listed)
        .toSorted((a, b) => a.order - b.order);
};

export const registeredPages = function registeredPages(): readonly PageEntry[] {
    return pages.all().toSorted((a, b) => a.order - b.order);
};

export const loadedPage = function loadedPage(id: string): PageDefinition | undefined {
    return loaded.get(id);
};

export const loadPage = async function loadPage(id: string): Promise<PageDefinition | undefined> {
    const held = loaded.get(id);
    if (held !== undefined) {
        return held;
    }
    const entry = pages.byId(id);
    if (entry === undefined) {
        return undefined;
    }
    const inFlight = pending.get(id);
    if (inFlight !== undefined) {
        return inFlight;
    }
    const loading = entry.load().then((definition) => {
        loaded.set(id, definition);
        pending.delete(id);
        return definition;
    });
    pending.set(id, loading);
    return loading;
};
```