# core/validators/reason.reference.validator.ts

> 73 lines of code and 9 definitions.

Tree: GovLab Context
Language: typescript
Layer: processing
Canonical: https://banes-lab.com/anatomy/context#file-context-core-validators-reason-reference-validator-ts
Source text: https://banes-lab.com/source/context/core/validators/reason.reference.validator.ts.txt

Listed in [core/validators](https://banes-lab.com/api/source/context/core/validators.md), after [core/validators/ontology.validator.ts](https://banes-lab.com/source/context/core/validators/ontology.validator.ts.md) and before [core/validators/reason.validator.ts](https://banes-lab.com/source/context/core/validators/reason.validator.ts.md).

## Definitions

- `resolve` (lexical_declaration, line 73, exported)
- `reasonDefectLines` (lexical_declaration, line 29, exported)
- `idShapedEdgeLabelsOf` (lexical_declaration, line 70, exported)
- `unresolvedReasonEdgesOf` (lexical_declaration, line 21, exported)
- `unresolvedLensDetectorsOf` (lexical_declaration, line 43, exported)
- `unresolvedShapeInstancesOf` (lexical_declaration, line 55, exported)
- `isIdShaped` (lexical_declaration, line 66)
- `EdgeFaces` (type_alias_declaration, line 17)
- `LensFaces` (type_alias_declaration, line 19)

## Contained in

- [core/validators](https://banes-lab.com/anatomy/context/folder-context-core-validators.md)

## Uses

- [configuration/strings/validation.strings.ts](https://banes-lab.com/source/context/configuration/strings/validation.strings.ts.md)
- [core/resolvers/reference.resolver.ts](https://banes-lab.com/source/context/core/resolvers/reference.resolver.ts.md)

## Used by

- [core/validators/ontology.validator.ts](https://banes-lab.com/source/context/core/validators/ontology.validator.ts.md)

## Linked from

- [configuration/strings](https://banes-lab.com/anatomy/context/folder-context-configuration-strings.md)
- [core/resolvers](https://banes-lab.com/anatomy/context/folder-context-core-resolvers.md)
- [core/validators](https://banes-lab.com/anatomy/context/folder-context-core-validators.md)

## Source

```typescript
import type { CollectionRefFaces, TargetResolverFaces } from "#types/reference.types";
import { ID_LABEL_SEPARATORS, LABEL_SPACE } from "#configuration/constants/reference.constants";
import {
    answerShapeMismatch,
    collidingCell,
    danglingConcept,
    danglingEdgeSource,
    danglingReasonField,
    danglingTransition,
    duplicateReasonId,
    emptyReasonField,
    unresolvedModelStep,
} from "#configuration/strings/validation.strings";
import { collectionRefResolver, resolveTarget } from "#core/resolvers/reference.resolver";
import type { ReasonOntologyIssues } from "#types/reason.types";

type EdgeFaces = TargetResolverFaces & { reason: { edges: () => { to?: string }[] } };

type LensFaces = TargetResolverFaces & { reason: { lenses: () => { detectedBy?: string[]; id: string }[] } };

export const unresolvedReasonEdgesOf = function unresolvedReasonEdgesOf(faces: EdgeFaces): string[] {
    return faces.reason
        .edges()
        .filter((edge) => typeof edge.to === "string" && !resolveTarget(faces, edge.to))
        .map((edge) => edge.to ?? "")
        .toSorted((a, b) => a.localeCompare(b));
};

export const reasonDefectLines = function reasonDefectLines(issues: ReasonOntologyIssues): string[] {
    return [
        ...issues.duplicateIds.map(duplicateReasonId),
        ...issues.danglingConcepts.map((entry) => danglingConcept(entry.node, entry.concept)),
        ...issues.danglingFields.map(danglingReasonField),
        ...issues.emptyFields.map(emptyReasonField),
        ...issues.danglingTransitions.map(danglingTransition),
        ...issues.danglingEdgeSources.map(danglingEdgeSource),
        ...issues.collidingSurfaceCells.map((entry) => collidingCell(entry.cell, entry.surfaces)),
        ...issues.answerShapeMismatches.map(answerShapeMismatch),
        ...issues.unresolvedModelSteps.map(unresolvedModelStep),
    ];
};

export const unresolvedLensDetectorsOf = function unresolvedLensDetectorsOf(
    faces: LensFaces,
): { lens: string; target: string }[] {
    return faces.reason
        .lenses()
        .flatMap((lens) =>
            (lens.detectedBy ?? [])
                .filter((target) => !resolveTarget(faces, target))
                .map((target) => ({ lens: lens.id, target })),
        );
};

export const unresolvedShapeInstancesOf = function unresolvedShapeInstancesOf(
    faces: CollectionRefFaces & { reason: { failureShapes: () => { id: string; instances: readonly string[] }[] } },
): { shape: string; instance: string }[] {
    const resolve = collectionRefResolver(faces);
    return faces.reason
        .failureShapes()
        .flatMap((shape) =>
            shape.instances.filter((instance) => !resolve(instance)).map((instance) => ({ instance, shape: shape.id })),
        );
};

const isIdShaped = function isIdShaped(label: string): boolean {
    return !label.includes(LABEL_SPACE) && ID_LABEL_SEPARATORS.some((separator) => label.includes(separator));
};

export const idShapedEdgeLabelsOf = function idShapedEdgeLabelsOf(
    faces: CollectionRefFaces & { reason: { edges: () => { from: string; label?: string }[] } },
): { from: string; label: string }[] {
    const resolve = collectionRefResolver(faces);
    return faces.reason
        .edges()
        .flatMap((edge) =>
            typeof edge.label === "string" && isIdShaped(edge.label) && !resolve(edge.label)
                ? [{ from: edge.from, label: edge.label }]
                : [],
        );
};
```