# core/converters/reason.catalog.converter.ts

> 110 lines of code and 13 definitions.

Tree: Bane's Lab Build Scripts
Language: typescript
Layer: processing
Canonical: https://banes-lab.com/anatomy/build-scripts#file-build-scripts-core-converters-reason-catalog-converter-ts
Source text: https://banes-lab.com/source/build-scripts/core/converters/reason.catalog.converter.ts.txt

Listed in [core/converters](https://banes-lab.com/api/source/build-scripts/core/converters.md), after [core/converters/payload.converter.ts](https://banes-lab.com/source/build-scripts/core/converters/payload.converter.ts.md) and before [core/converters/reason.converter.ts](https://banes-lab.com/source/build-scripts/core/converters/reason.converter.ts.md).

## Definitions

- `reverseOf` (lexical_declaration, line 39)
- `catalogsOf` (lexical_declaration, line 69, exported)
- `surfaceCatalogs` (lexical_declaration, line 48)
- `Catalogs` (type_alias_declaration, line 34)
- `dimensions` (lexical_declaration, line 50)
- `invariants` (lexical_declaration, line 58)
- `{ context, resolve }` (lexical_declaration, line 70, exported)
- `{ reason }` (lexical_declaration, line 71, exported)
- `layers` (lexical_declaration, line 72, exported)
- `mathTypes` (lexical_declaration, line 79, exported)
- `modes` (lexical_declaration, line 87, exported)
- `techniques` (lexical_declaration, line 96, exported)
- `universalAxes` (lexical_declaration, line 105, exported)

## Contained in

- [core/converters](https://banes-lab.com/anatomy/build-scripts/folder-build-scripts-core-converters.md)

## Uses

- [core/converters/ontology.index.converter.ts](https://banes-lab.com/source/build-scripts/core/converters/ontology.index.converter.ts.md)
- [core/resolvers/ontology.resolver.ts](https://banes-lab.com/source/build-scripts/core/resolvers/ontology.resolver.ts.md)

## Used by

- [core/converters/reason.converter.ts](https://banes-lab.com/source/build-scripts/core/converters/reason.converter.ts.md)
- [core/coordinators/catalog.coordinator.ts](https://banes-lab.com/source/build-scripts/core/coordinators/catalog.coordinator.ts.md)

## Linked from

- [core/converters](https://banes-lab.com/anatomy/build-scripts/folder-build-scripts-core-converters.md)
- [core/coordinators](https://banes-lab.com/anatomy/build-scripts/folder-build-scripts-core-coordinators.md)
- [core/resolvers](https://banes-lab.com/anatomy/build-scripts/folder-build-scripts-core-resolvers.md)

## Source

```typescript
import {
    AXES_RELATION,
    LENSES_RELATION,
    SURFACES_RELATION,
    TECHNIQUES_RELATION,
} from "#configuration/constants/graph.constants";
import { CONTRACTS_RELATION, GROUNDED_BY_RELATION, REASON_FACE } from "@govlab/constants";
import {
    DIMENSION_KIND,
    INVARIANT_KIND,
    MATH_DOMAIN_KIND,
    MATH_TYPE_KIND,
    MODE_KIND,
    REASON_LAYER_KIND,
    TECHNIQUE_KIND,
    UNIVERSAL_AXIS_KIND,
} from "#configuration/constants/ontology.constants";
import type {
    DimensionView,
    InvariantView,
    MathTypeView,
    ModeView,
    ReasonLayerView,
    ReasonView,
    TechniqueView,
    UniversalAxisView,
} from "@banes-lab/web/types/reason.types.js";
import type { EdgeRef } from "@banes-lab/web/types/link.types.js";
import type { ReasonSources } from "#types/ontology.types";
import { lookup } from "#core/converters/ontology.index.converter";
import { orNull } from "#core/converters/base.converter";
import { reasonAnchor } from "#core/resolvers/ontology.resolver";

type Catalogs = Pick<
    ReasonView,
    "dimensions" | "invariants" | "layers" | "mathTypes" | "modes" | "techniques" | "universalAxes"
>;

const reverseOf = function reverseOf(
    sources: ReasonSources,
    relation: string,
    kind: string,
    id: string,
): readonly EdgeRef[] {
    return lookup(sources.index, relation, REASON_FACE, reasonAnchor(kind, id));
};

const surfaceCatalogs = function surfaceCatalogs(sources: ReasonSources): Pick<Catalogs, "dimensions" | "invariants"> {
    const { reason } = sources.context;
    const dimensions: DimensionView[] = reason
        .dimensions()
        .map((dimension) => ({
            ...dimension,
            anchor: reasonAnchor(DIMENSION_KIND, dimension.id),
            mathDomains: dimension.mathDomains.map((domain) => sources.resolve.reasonAs(MATH_DOMAIN_KIND, domain)),
            surfaces: reverseOf(sources, SURFACES_RELATION, DIMENSION_KIND, dimension.id),
        }));
    const invariants: InvariantView[] = reason
        .invariants()
        .map((invariant) => ({
            ...invariant,
            anchor: reasonAnchor(INVARIANT_KIND, invariant.id),
            groundedBy: reverseOf(sources, GROUNDED_BY_RELATION, INVARIANT_KIND, invariant.id),
            surfaces: reverseOf(sources, SURFACES_RELATION, INVARIANT_KIND, invariant.id),
        }));
    return { dimensions, invariants };
};

export const catalogsOf = function catalogsOf(sources: ReasonSources): Catalogs {
    const { context, resolve } = sources;
    const { reason } = context;
    const layers: ReasonLayerView[] = reason
        .layers()
        .map((layer) => ({
            ...layer,
            anchor: reasonAnchor(REASON_LAYER_KIND, layer.id),
            axes: reverseOf(sources, AXES_RELATION, REASON_LAYER_KIND, layer.id),
        }));
    const mathTypes: MathTypeView[] = reason
        .mathTypes()
        .map((mathType) => ({
            ...mathType,
            anchor: reasonAnchor(MATH_TYPE_KIND, mathType.id),
            contracts: reverseOf(sources, CONTRACTS_RELATION, MATH_TYPE_KIND, mathType.id),
            mathDomains: mathType.domains.map((domain) => resolve.reasonAs(MATH_DOMAIN_KIND, domain)),
        }));
    const modes: ModeView[] = reason
        .modes()
        .map((mode) => ({
            anchor: reasonAnchor(MODE_KIND, mode.id),
            id: mode.id,
            practice: mode.practice,
            question: orNull(mode.question),
            techniques: reverseOf(sources, TECHNIQUES_RELATION, MODE_KIND, mode.id),
        }));
    const techniques: TechniqueView[] = reason
        .techniques()
        .map((technique) => ({
            ...technique,
            anchor: reasonAnchor(TECHNIQUE_KIND, technique.id),
            mode: resolve.reasonAs(MODE_KIND, technique.mode),
            principleRef: technique.principleRef === undefined ? null : resolve.archId(technique.principleRef),
            surfaces: reverseOf(sources, SURFACES_RELATION, TECHNIQUE_KIND, technique.id),
        }));
    const universalAxes: UniversalAxisView[] = reason
        .universalAxes()
        .map((axis) => ({
            ...axis,
            anchor: reasonAnchor(UNIVERSAL_AXIS_KIND, axis.id),
            lenses: reverseOf(sources, LENSES_RELATION, UNIVERSAL_AXIS_KIND, axis.id),
            subsumes: axis.subsumes.map((subsumed) => resolve.reasonAs(DIMENSION_KIND, subsumed)),
        }));
    return { ...surfaceCatalogs(sources), layers, mathTypes, modes, techniques, universalAxes };
};
```