@eightyfourthousand/data-access 2026.4.0 → 2026.4.2

package/src/lib/types/annotation/link.ts

@@ -1,38 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type LinkAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): LinkAnnotation => {
-  const linkAnnotation = baseAnnotationFromDTO(dto) as LinkAnnotation;
-  dto.content.forEach((content) => {
-    if (content.title) {
-      linkAnnotation.text = content.title as string;
-    }
-
-    if (content.href) {
-      linkAnnotation.href = content.href as string;
-    }
-  });
-
-  return linkAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { href, text } = annotation as LinkAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-  dto.content.push({
-    href,
-  });
-
-  if (text) {
-    dto.content.push({
-      title: text,
-    });
-  }
-  return dto;
-};

package/src/lib/types/annotation/list-item.ts

@@ -1,16 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type ListItemAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): ListItemAnnotation => {
-  return baseAnnotationFromDTO(dto) as ListItemAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/list.ts

@@ -1,43 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type ListAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): ListAnnotation => {
-  const listAnnotation = baseAnnotationFromDTO(dto) as ListAnnotation;
-  dto.content.forEach((content) => {
-    if (content['list-spacing']) {
-      listAnnotation.spacing = content['list-spacing'] as string;
-    }
-
-    if (content['list-item-style']) {
-      listAnnotation.itemStyle = content['list-item-style'] as string;
-    }
-
-    if (content.nesting) {
-      listAnnotation.nesting = Number.parseInt(content.nesting as string);
-    }
-  });
-
-  return listAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { spacing, nesting, itemStyle } = annotation as ListAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-  if (spacing) {
-    dto.content.push({ 'list-spacing': spacing });
-  }
-  if (nesting) {
-    dto.content.push({ nesting });
-  }
-  if (itemStyle) {
-    dto.content.push({ 'list-item-style': itemStyle });
-  }
-
-  return dto;
-};

package/src/lib/types/annotation/mantra.ts

@@ -1,31 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type MantraAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-import type { ExtendedTranslationLanguage } from '../language';
-
-export const transformer: AnnotationTransformer = (dto): MantraAnnotation => {
-  const mantraAnnotation = baseAnnotationFromDTO(dto) as MantraAnnotation;
-  dto.content.forEach((content) => {
-    if (content.lang) {
-      mantraAnnotation.lang = content.lang as ExtendedTranslationLanguage;
-    }
-  });
-  return mantraAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { lang } = annotation as MantraAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-
-  if (lang) {
-    dto.content.push({
-      lang,
-    });
-  }
-  return dto;
-};

package/src/lib/types/annotation/mention.ts

@@ -1,64 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type MentionAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (
-  dto,
-): MentionAnnotation => {
-  const mention = baseAnnotationFromDTO(dto) as MentionAnnotation;
-  dto.content.forEach((content) => {
-    if (content.uuid) {
-      mention.entity = content.uuid as string;
-    }
-    if (content.type) {
-      mention.linkType = content.type as string;
-    }
-    if (content.text) {
-      mention.text = content.text as string;
-    }
-    if (content.same_work !== undefined) {
-      mention.isSameWork = !!content.same_work;
-    }
-    if (content.subtype) {
-      mention.subtype = content.subtype as string;
-    }
-    if (content.toh) {
-      mention.linkToh = content.toh as string;
-    }
-  });
-
-  return mention;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { entity, linkType, text, isSameWork, subtype, linkToh } =
-    annotation as MentionAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-
-  if (entity) {
-    dto.content.push({ uuid: entity });
-  }
-  if (linkType) {
-    dto.content.push({ type: linkType });
-  }
-  // Persist custom override text, but NEVER persist displayText
-  if (text) {
-    dto.content.push({ text });
-  }
-  if (isSameWork !== undefined) {
-    dto.content.push({ same_work: isSameWork });
-  }
-  if (subtype) {
-    dto.content.push({ subtype });
-  }
-  if (linkToh) {
-    dto.content.push({ toh: linkToh });
-  }
-
-  return dto;
-};

package/src/lib/types/annotation/paragraph.ts

@@ -1,18 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type ParagraphAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (
-  dto,
-): ParagraphAnnotation => {
-  return baseAnnotationFromDTO(dto) as ParagraphAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/quote.ts

@@ -1,30 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type QuoteAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): QuoteAnnotation => {
-  const quoteAnnotation = baseAnnotationFromDTO(dto) as QuoteAnnotation;
-  dto.content.forEach((content) => {
-    if (content.uuid) {
-      quoteAnnotation.quote = content.uuid as string;
-    }
-  });
-
-  return quoteAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { quote } = annotation as QuoteAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-  if (quote) {
-    dto.content.push({
-      uuid: quote,
-    });
-  }
-  return dto;
-};

package/src/lib/types/annotation/quoted.ts

@@ -1,30 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type QuotedAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): QuotedAnnotation => {
-  const quotedAnnotation = baseAnnotationFromDTO(dto) as QuotedAnnotation;
-  dto.content.forEach((content) => {
-    if (content.uuid) {
-      quotedAnnotation.quote = content.uuid as string;
-    }
-  });
-
-  return quotedAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { quote } = annotation as QuotedAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-  if (quote) {
-    dto.content.push({
-      uuid: quote,
-    });
-  }
-  return dto;
-};

package/src/lib/types/annotation/reference.ts

@@ -1,18 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type ReferenceAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (
-  dto,
-): ReferenceAnnotation => {
-  return baseAnnotationFromDTO(dto) as ReferenceAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/span.ts

@@ -1,39 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type SpanAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-import type { ExtendedTranslationLanguage } from '../language';
-
-export const transformer: AnnotationTransformer = (dto): SpanAnnotation => {
-  const spanAnnotation = baseAnnotationFromDTO(dto) as SpanAnnotation;
-  dto.content.forEach((content) => {
-    if (content['text-style']) {
-      spanAnnotation.textStyle = content['text-style'] as string;
-    }
-
-    if (content.lang) {
-      spanAnnotation.lang = content.lang as ExtendedTranslationLanguage;
-    }
-  });
-  return spanAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  const { textStyle, lang } = annotation as SpanAnnotation;
-  const dto = baseAnnotationToDto(annotation);
-  if (textStyle) {
-    dto.content.push({
-      'text-style': textStyle,
-    });
-  }
-  if (lang) {
-    dto.content.push({
-      lang,
-    });
-  }
-  return dto;
-};

package/src/lib/types/annotation/table-body-data.ts

@@ -1,18 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type TableBodyDataAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (
-  dto,
-): TableBodyDataAnnotation => {
-  return baseAnnotationFromDTO(dto) as TableBodyDataAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/table-body-header.ts

@@ -1,18 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type TableBodyHeaderAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (
-  dto,
-): TableBodyHeaderAnnotation => {
-  return baseAnnotationFromDTO(dto) as TableBodyHeaderAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/table-body-row.ts

@@ -1,18 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type TableBodyRowAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (
-  dto,
-): TableBodyRowAnnotation => {
-  return baseAnnotationFromDTO(dto) as TableBodyRowAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/table.ts

@@ -1,16 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type TableAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): TableAnnotation => {
-  return baseAnnotationFromDTO(dto) as TableAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/trailer.ts

@@ -1,16 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type TrailerAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): TrailerAnnotation => {
-  return baseAnnotationFromDTO(dto) as TrailerAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/annotation/transform.ts

@@ -1,140 +0,0 @@
-import {
-  baseAnnotationFromDTO,
-  type UnknownAnnotation,
-  type Annotation,
-  type Annotations,
-  type AnnotationTransformer,
-} from './annotation';
-import type {
-  AnnotationDTO,
-  AnnotationsDTO,
-  AnnotationDTOType,
-} from './annotation-type';
-import { ANNOTATIONS_TO_IGNORE } from './annotation-type';
-import { transformer as abbreviation } from './abbreviation';
-import { transformer as audio } from './audio';
-import { transformer as blockquote } from './blockquote';
-import { transformer as code } from './code';
-import { transformer as deprecated } from './deprecated';
-import { transformer as endNoteLink } from './end-note-link';
-import { transformer as glossaryInstance } from './glossary-instance';
-import { transformer as hasAbbreviation } from './has-abbreviation';
-import { transformer as heading } from './heading';
-import { transformer as image } from './image';
-import { transformer as indent } from './indent';
-import { transformer as inlineTitle } from './inline-title';
-import { transformer as internalLink } from './internal-link';
-import { transformer as leadingSpace } from './leading-space';
-import { transformer as line } from './line';
-import { transformer as lineGroup } from './line-group';
-import { transformer as link } from './link';
-import { transformer as list } from './list';
-import { transformer as listItem } from './list-item';
-import { transformer as mantra } from './mantra';
-import { transformer as mention } from './mention';
-import { transformer as paragraph } from './paragraph';
-import { transformer as quote } from './quote';
-import { transformer as quoted } from './quoted';
-import { transformer as reference } from './reference';
-import { transformer as span } from './span';
-import { transformer as trailer } from './trailer';
-import { transformer as table } from './table';
-import { transformer as tableBodyData } from './table-body-data';
-import { transformer as tableBodyHeader } from './table-body-header';
-import { transformer as tableBodyRow } from './table-body-row';
-import { transformer as unknown } from './unknown';
-import { annotationToDtoMap } from './export';
-
-const dtoToAnnotationMap: Record<AnnotationDTOType, AnnotationTransformer> = {
-  abbreviation,
-  audio,
-  blockquote,
-  code,
-  'deprecated-internal-link': deprecated,
-  'end-note-link': endNoteLink,
-  'glossary-instance': glossaryInstance,
-  'has-abbreviation': hasAbbreviation,
-  heading,
-  image,
-  indent,
-  'inline-title': inlineTitle,
-  'internal-link': internalLink,
-  'leading-space': leadingSpace,
-  line,
-  'line-group': lineGroup,
-  link,
-  list,
-  'list-item': listItem,
-  mantra,
-  mention,
-  paragraph,
-  quote,
-  quoted,
-  reference,
-  span,
-  table,
-  'table-body-data': tableBodyData,
-  'table-body-header': tableBodyHeader,
-  'table-body-row': tableBodyRow,
-  trailer,
-  unknown,
-};
-
-export const annotationFromDTO = (
-  dto: AnnotationDTO,
-  passageLength: number,
-): Annotation => {
-  const annotation = dtoToAnnotationMap[dto.type]?.(dto);
-  if (!annotation) {
-    console.warn(`Unknown annotation type: ${dto.type}`);
-    console.warn(dto);
-    return {
-      ...baseAnnotationFromDTO(dto),
-      type: 'unknown',
-    } as UnknownAnnotation;
-  }
-
-  if (
-    annotation.start < 0 ||
-    annotation.start > passageLength ||
-    annotation.end < 0 ||
-    annotation.end > passageLength
-  ) {
-    annotation.validated = false;
-  }
-
-  if (!annotation.validated) {
-    console.warn(
-      `Invalid annotation range for annotation ${annotation.uuid} (${annotation.start}, ${annotation.end}) in passage of length ${passageLength}`,
-    );
-  }
-
-  return annotation;
-};
-
-export const annotationsFromDTO = (
-  dto?: AnnotationsDTO,
-  passageLength?: number,
-): Annotations => {
-  const filtered =
-    dto?.filter((a) => !ANNOTATIONS_TO_IGNORE.includes(a.type)) || [];
-  return filtered.map((a) => annotationFromDTO(a, passageLength || 0));
-};
-
-export const annotationToDTO = (
-  annotation: Annotation,
-): AnnotationDTO | undefined => {
-  const dto = annotationToDtoMap[annotation.type]?.(annotation);
-  if (!dto) {
-    console.warn(`Unknown annotation type: ${annotation.type}`);
-    console.warn(annotation);
-    return;
-  }
-  return dto;
-};
-
-export const annotationsToDTO = (annotations: Annotations): AnnotationsDTO => {
-  return annotations
-    .map(annotationToDTO)
-    .filter((a): a is AnnotationDTO => a !== undefined);
-};

package/src/lib/types/annotation/unknown.ts

@@ -1,16 +0,0 @@
-import type { AnnotationDTO } from './annotation-type';
-import {
-  type AnnotationExporter,
-  type AnnotationTransformer,
-  type UnknownAnnotation,
-  baseAnnotationFromDTO,
-  baseAnnotationToDto,
-} from './annotation';
-
-export const transformer: AnnotationTransformer = (dto): UnknownAnnotation => {
-  return baseAnnotationFromDTO(dto) as UnknownAnnotation;
-};
-
-export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
-  return baseAnnotationToDto(annotation);
-};

package/src/lib/types/bibliography.ts

@@ -1,86 +0,0 @@
-export type BibliographyItem = {
-  content?: string | null;
-  title: string;
-  uuid: string;
-  year: string;
-  publisher: string;
-};
-
-export type Bibliography = BibliographyItem[];
-
-export type BibliographyItemDTO = {
-  content?: string | null;
-  title: string;
-  uuid: string;
-  year: string;
-  publisher: string;
-};
-
-export type BibliographyDTO = BibliographyItemDTO[];
-
-export const bibliographyItemFromDTO = (
-  dto: BibliographyItemDTO,
-): BibliographyItem => {
-  return {
-    content: dto.content,
-    title: dto.title,
-    uuid: dto.uuid,
-    year: dto.year,
-    publisher: dto.publisher,
-  };
-};
-
-export type BibliographyEntryItemDTO = {
-  uuid: string;
-  bibl_html: string;
-  work_uuid?: string;
-};
-
-export type BibliographyEntryItem = {
-  uuid: string;
-  html: string;
-  workUuid?: string;
-};
-
-export type BlibliographyEntryDTO = {
-  heading?: string;
-  entries: BibliographyEntryItemDTO[];
-};
-
-export type BibliographyEntry = {
-  heading?: string;
-  entries: BibliographyEntryItem[];
-};
-
-export type BibliographyEntriesDTO = BlibliographyEntryDTO[];
-
-export type BibliographyEntries = BibliographyEntry[];
-
-export const bibliographyEntryItemFromDTO = (
-  dto: BibliographyEntryItemDTO,
-): BibliographyEntryItem => {
-  return {
-    uuid: dto.uuid,
-    html: dto.bibl_html,
-    workUuid: dto.work_uuid,
-  };
-};
-
-export const bibliographyEntryFromDTO = (
-  dto: BlibliographyEntryDTO,
-): BibliographyEntry => {
-  return {
-    heading: dto.heading,
-    entries: dto.entries?.map(bibliographyEntryItemFromDTO) || [],
-  };
-};
-
-export const bibliographyEntriesFromDTO = (
-  dtos: BibliographyEntriesDTO,
-): BibliographyEntries => {
-  return dtos?.map(bibliographyEntryFromDTO) || [];
-};
-
-export const bibliographyFromDTO = (dto?: BibliographyDTO): Bibliography => {
-  return dto?.map(bibliographyItemFromDTO) || [];
-};