@eightyfourthousand/data-access 2026.3.0

package/src/lib/types/annotation/has-abbreviation.ts

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

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

@@ -0,0 +1,37 @@
+import type { AnnotationDTO } from './annotation-type';
+import {
+  type AnnotationExporter,
+  type AnnotationTransformer,
+  type HeadingAnnotation,
+  HeadingClass,
+  baseAnnotationFromDTO,
+  baseAnnotationToDto,
+} from './annotation';
+
+export const transformer: AnnotationTransformer = (dto): HeadingAnnotation => {
+  const heading = baseAnnotationFromDTO(dto) as HeadingAnnotation;
+  dto.content.forEach((content) => {
+    if (content['heading-level']) {
+      const headerStr = content['heading-level'] as string;
+      const levelStr = headerStr.replace('h', '');
+      const level = parseInt(levelStr, 10);
+      heading.level = level;
+    }
+
+    if (content['heading-type']) {
+      heading.class = content['heading-type'] as HeadingClass;
+    }
+  });
+
+  return heading;
+};
+
+export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
+  const { level, class: headingClass } = annotation as HeadingAnnotation;
+  const dto = baseAnnotationToDto(annotation);
+  dto.content.push({
+    'heading-level': `h${level}`,
+    ...(headingClass ? { 'heading-type': headingClass } : {}),
+  });
+  return dto;
+};

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

@@ -0,0 +1,29 @@
+import type { AnnotationDTO } from './annotation-type';
+import {
+  type AnnotationExporter,
+  type AnnotationTransformer,
+  type ImageAnnotation,
+  baseAnnotationFromDTO,
+  baseAnnotationToDto,
+} from './annotation';
+
+export const transformer: AnnotationTransformer = (dto): ImageAnnotation => {
+  const baseAnnotation = baseAnnotationFromDTO(dto);
+  const image = baseAnnotation as ImageAnnotation;
+  dto.content.forEach((content) => {
+    if (content.src) {
+      image.src = content.src as string;
+    }
+  });
+
+  return image;
+};
+
+export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
+  const { src } = annotation as ImageAnnotation;
+  const dto = baseAnnotationToDto(annotation);
+  dto.content.push({
+    src,
+  });
+  return dto;
+};

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

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

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

@@ -0,0 +1,4 @@
+export * from './annotation';
+export * from './annotation-type';
+export * from './export';
+export * from './transform';

package/src/lib/types/annotation/inline-title.ts

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

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

@@ -0,0 +1,86 @@
+import type { AnnotationDTO } from './annotation-type';
+import {
+  type AnnotationExporter,
+  type AnnotationTransformer,
+  type InternalLinkAnnotation,
+  baseAnnotationFromDTO,
+  baseAnnotationToDto,
+} from './annotation';
+
+export const transformer: AnnotationTransformer = (
+  dto,
+): InternalLinkAnnotation => {
+  const internalLink = baseAnnotationFromDTO(dto) as InternalLinkAnnotation;
+  dto.content.forEach((content) => {
+    if (content.href) {
+      internalLink.href = content.href as string;
+    }
+
+    if (content['link-type']) {
+      internalLink.isPending = true;
+    }
+
+    if (content.type) {
+      internalLink.linkType = content['type'] as string;
+    }
+
+    if (content.label) {
+      internalLink.label = content.label as string;
+    }
+
+    if (content.uuid) {
+      internalLink.entity = content.uuid as string;
+    }
+
+    if (content.same_work !== undefined) {
+      internalLink.isSameWork = !!content.same_work;
+    }
+
+    if (content.subtype) {
+      internalLink.subtype = content.subtype as string;
+    }
+
+    if (content.toh) {
+      internalLink.linkToh = content.toh as string;
+    }
+  });
+
+  return internalLink;
+};
+
+export const exporter: AnnotationExporter = (annotation): AnnotationDTO => {
+  const { entity, linkType, href, label, isPending } =
+    annotation as InternalLinkAnnotation;
+  const dto = baseAnnotationToDto(annotation);
+  dto.content = [
+    {
+      href,
+    },
+  ];
+
+  if (isPending) {
+    dto.content.push({
+      'link-type': 'pending',
+    });
+  }
+
+  if (label) {
+    dto.content.push({
+      label,
+    });
+  }
+
+  if (entity) {
+    dto.content.push({
+      uuid: entity,
+    });
+  }
+
+  if (linkType) {
+    dto.content.push({
+      type: linkType,
+    });
+  }
+
+  return dto;
+};

package/src/lib/types/annotation/leading-space.ts

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

package/src/lib/types/annotation/line-group.ts

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

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

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

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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);
+};