# core/converters/folder.converter.ts

> 90 lines of code and 17 definitions.

Tree: Site tree
Language: typescript
Layer: processing
Canonical: https://banes-lab.com/anatomy/tree#file-core-converters-folder-converter-ts
Source text: https://banes-lab.com/assets/sources/source.9e9dfa8030e876be5c127a8ff6874a07691ebd50f7768b53f64e01d0d46b39a4.generated.txt

## Definitions

- `qualifiedPath` (lexical_declaration, line 31, exported)
- `treeOf` (lexical_declaration, line 35, exported)
- `localPath` (lexical_declaration, line 40, exported)
- `qualifiedFinding` (lexical_declaration, line 65)
- `qualifiedRef` (lexical_declaration, line 51)
- `qualifiedDefinition` (lexical_declaration, line 55)
- `qualifiedFile` (lexical_declaration, line 69)
- `qualifiedFolder` (lexical_declaration, line 79)
- `parentPath` (lexical_declaration, line 45, exported)
- `qualifiedSnapshot` (lexical_declaration, line 90, exported)
- `targetOf` (lexical_declaration, line 14, exported)
- `fragment` (lexical_declaration, line 19, exported)
- `mark` (lexical_declaration, line 20, exported)
- `tail` (lexical_declaration, line 24, exported)
- `line` (lexical_declaration, line 25, exported)
- `local` (lexical_declaration, line 46, exported)
- `cut` (lexical_declaration, line 47, exported)

## Used by

- [core/loaders/definition.loader.ts](https://banes-lab.com/source/tree/core/loaders/definition.loader.ts.md)
- [core/loaders/walk.loader.ts](https://banes-lab.com/source/tree/core/loaders/walk.loader.ts.md)
- [domain/converters/anatomy.converter.ts](https://banes-lab.com/source/tree/domain/converters/anatomy.converter.ts.md)
- [domain/converters/source.converter.ts](https://banes-lab.com/source/tree/domain/converters/source.converter.ts.md)
- [domain/loaders/anatomy.loader.ts](https://banes-lab.com/source/tree/domain/loaders/anatomy.loader.ts.md)

## Source

```typescript
import type {
    AnatomyFile,
    AnatomyFolder,
    AnatomySnapshot,
    DefinitionRef,
    DefinitionView,
    FindingView,
} from "#types/anatomy.types";
import { LINE_INFIX, PATH_SEPARATOR, TREE_MARK } from "#configuration/constants/anatomy.constants";
import { ANCHOR_PREFIX } from "#configuration/constants/document.constants";
import type { NodeTarget } from "#types/folder.types";
import { TREE_TAB } from "#core/ids/anatomy.ids";

export const targetOf = function targetOf(href: string): NodeTarget | null {
    const cut = href.lastIndexOf(ANCHOR_PREFIX);
    if (cut === -1) {
        return null;
    }
    const fragment = href.slice(cut + ANCHOR_PREFIX.length);
    const mark = fragment.indexOf(LINE_INFIX);
    if (mark === -1) {
        return { id: fragment, line: null, text: null };
    }
    const tail = fragment.slice(mark + LINE_INFIX.length);
    const line = Number(tail);
    return Number.isInteger(line)
        ? { id: fragment.slice(0, mark), line, text: null }
        : { id: fragment.slice(0, mark), line: null, text: tail };
};

export const qualifiedPath = function qualifiedPath(tree: string, path: string): string {
    return tree === TREE_TAB ? path : tree + TREE_MARK + path;
};

export const treeOf = function treeOf(path: string): string {
    const cut = path.indexOf(TREE_MARK);
    return cut === -1 ? TREE_TAB : path.slice(0, cut);
};

export const localPath = function localPath(path: string): string {
    const cut = path.indexOf(TREE_MARK);
    return cut === -1 ? path : path.slice(cut + TREE_MARK.length);
};

export const parentPath = function parentPath(path: string): string {
    const local = localPath(path);
    const cut = local.lastIndexOf(PATH_SEPARATOR);
    return qualifiedPath(treeOf(path), cut === -1 ? "" : local.slice(0, cut));
};

const qualifiedRef = function qualifiedRef(tree: string, ref: DefinitionRef): DefinitionRef {
    return { ...ref, file: qualifiedPath(tree, ref.file), id: qualifiedPath(tree, ref.id) };
};

const qualifiedDefinition = function qualifiedDefinition(tree: string, definition: DefinitionView): DefinitionView {
    return {
        ...definition,
        callees: definition.callees.map((ref) => qualifiedRef(tree, ref)),
        callers: definition.callers.map((ref) => qualifiedRef(tree, ref)),
        file: qualifiedPath(tree, definition.file),
        id: qualifiedPath(tree, definition.id),
    };
};

const qualifiedFinding = function qualifiedFinding(tree: string, finding: FindingView): FindingView {
    return { ...finding, file: qualifiedPath(tree, finding.file) };
};

const qualifiedFile = function qualifiedFile(tree: string, file: AnatomyFile): AnatomyFile {
    return {
        ...file,
        definitions: file.definitions.map((definition) => qualifiedDefinition(tree, definition)),
        findings: file.findings.map((finding) => qualifiedFinding(tree, finding)),
        id: qualifiedPath(tree, file.id),
        path: qualifiedPath(tree, file.path),
    };
};

const qualifiedFolder = function qualifiedFolder(tree: string, folder: AnatomyFolder): AnatomyFolder {
    return {
        ...folder,
        files: folder.files.map((file) => qualifiedFile(tree, file)),
        findings: folder.findings.map((finding) => qualifiedFinding(tree, finding)),
        folders: folder.folders.map((child) => qualifiedFolder(tree, child)),
        id: qualifiedPath(tree, folder.id),
        path: qualifiedPath(tree, folder.path),
    };
};

export const qualifiedSnapshot = function qualifiedSnapshot(tree: string, snapshot: AnatomySnapshot): AnatomySnapshot {
    return {
        ...snapshot,
        findings: snapshot.findings.map((finding) => qualifiedFinding(tree, finding)),
        imports: snapshot.imports.map((edge) => ({
            ...edge,
            from: qualifiedPath(tree, edge.from),
            to: qualifiedPath(tree, edge.to),
        })),
        tree: qualifiedFolder(tree, snapshot.tree),
    };
};
```