@eightyfourthousand/data-access 2026.3.0

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

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

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

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

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

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

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

package/src/lib/types/canon.ts

@@ -0,0 +1,148 @@
+import { TohokuCatalogEntry } from './toh';
+import { ExtendedTranslationLanguage } from './language';
+
+export type CanonNodeType =
+  | 'root'
+  | 'canonicalSection'
+  | 'nonCanonicalSection'
+  | 'textGrouping';
+
+export type CanonDTO = {
+  uuid: string;
+  created_at: string;
+  label: string;
+  parent_uuid?: string;
+  xmlId: string;
+  parent_xmlId?: string;
+  sort: number;
+  description: string;
+  type: CanonNodeType;
+  public_description?: string;
+  article_uuid?: string;
+};
+
+export type CanonHead = {
+  children: CanonNode[];
+};
+
+export type CanonNode = {
+  uuid: string;
+  label?: string;
+  xmlId?: string;
+  parentXmlId?: string;
+  parentUuid?: string;
+  sort: number;
+  description?: string;
+  type: CanonNodeType;
+  publicDescription?: string;
+  articleUuid?: string;
+  children?: CanonNode[];
+  createdAt?: string;
+};
+
+export type CanonArticleDTO = {
+  uuid: string;
+  title: string;
+  body: string;
+  image?: string;
+  caption?: string;
+};
+
+export type CanonArticle = CanonArticleDTO;
+
+export type CanonArticleTitleDTO = {
+  title: string;
+  language: ExtendedTranslationLanguage;
+};
+
+export type CanonArticleTitle = CanonArticleTitleDTO;
+
+export type CanonDetailDTO = {
+  uuid: string;
+  label: string;
+  description: string;
+  type: CanonNodeType;
+  article?: CanonArticleDTO;
+  titles: CanonArticleTitleDTO[];
+};
+export type CanonDetail = CanonDetailDTO & {
+  article?: CanonArticle;
+  titles: CanonArticleTitle[];
+};
+
+export type CanonWorkStatus = 'published' | 'in-progress' | 'not-started';
+
+export type CanonWorkDTO = {
+  uuid: string;
+  toh: TohokuCatalogEntry;
+  title: string;
+  published: boolean;
+  status: CanonWorkStatus;
+  pages: number;
+};
+
+export type CanonWork = CanonWorkDTO;
+
+export type CanonWorksDTO = {
+  works: CanonWorkDTO[];
+};
+
+export const canonNodeFromDTO = (dto: CanonDTO): CanonNode => {
+  return {
+    uuid: dto.uuid,
+    label: dto.label,
+    xmlId: dto.xmlId,
+    parentXmlId: dto.parent_xmlId,
+    parentUuid: dto.parent_uuid,
+    sort: dto.sort,
+    description: dto.description,
+    type: dto.type,
+    publicDescription: dto.public_description,
+    articleUuid: dto.article_uuid,
+    createdAt: dto.created_at,
+  };
+};
+
+export const canonTreeFromDTOs = (dtos: CanonDTO[]): CanonHead => {
+  const nodes: Record<string, CanonNode> = {};
+  dtos.forEach((dto) => {
+    nodes[dto.uuid] = canonNodeFromDTO(dto);
+  });
+
+  const tree: CanonNode[] = [];
+
+  Object.values(nodes).forEach((node) => {
+    if (node.parentUuid) {
+      const parent = nodes[node.parentUuid];
+      if (parent) {
+        parent.children = parent.children || [];
+        parent.children.push(node);
+      }
+    } else {
+      tree.push(node);
+    }
+  });
+
+  // Sort children by their sort order
+  const sortChildren = (children: CanonNode[]) => {
+    children.sort((a, b) => a.sort - b.sort);
+    children.forEach((child) => {
+      if (child.children) {
+        sortChildren(child.children);
+      }
+    });
+  };
+  sortChildren(tree);
+
+  return {
+    children: tree,
+  };
+};
+
+export const canonDetailFromDTO = (dto: CanonDetailDTO): CanonDetail => {
+  return dto as CanonDetail;
+};
+
+export const caononWorksFromDTO = (dto: CanonWorksDTO): CanonWork[] => {
+  return dto.works as CanonWork[];
+};

package/src/lib/types/client.ts

@@ -0,0 +1,3 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+export type DataClient = SupabaseClient;

package/src/lib/types/contributor.ts

@@ -0,0 +1,84 @@
+export type ContributorRole =
+  | 'englishAdvisor'
+  | 'englishAssociateEditor'
+  | 'englishCopyEditor'
+  | 'englishDharmaMaster'
+  | 'englishFinalReviewer'
+  | 'englishMarkup'
+  | 'englishProjectEditor'
+  | 'englishProjectManager'
+  | 'englishProofReader'
+  | 'englishReviser'
+  | 'englishTranslator'
+  | 'englishTranslationSponsor'
+  | 'englishTranslationTeam'
+  | 'tibetanTranslator';
+
+export type Contributor = {
+  name: string;
+  role: ContributorRole;
+};
+
+export type ProjectContributor = Contributor & {
+  uuid: string;
+  contributorUuid: string;
+  startDate?: Date;
+  endDate?: Date;
+  projectUuid: string;
+  stageUuid?: string;
+};
+
+export type Contributors = Contributor[];
+export type ProjectContributors = ProjectContributor[];
+
+export type ContributorDTO = {
+  name: string;
+  role: ContributorRole;
+};
+
+export type ContributorsDTO = ContributorDTO[];
+
+export type ProjectContributorDTO = {
+  uuid: string;
+  projectUuid: string;
+  stageUuid?: string;
+  contributorUuid: string;
+  name: string;
+  role: ContributorRole;
+  startDate: string;
+  endDate: string;
+};
+
+export type ProjectContributorsDTO = ProjectContributorDTO[];
+
+export const contributorFromDTO = (dto: ContributorDTO): Contributor => {
+  return {
+    name: dto.name,
+    role: dto.role,
+  };
+};
+
+export const contributorsFromDTO = (dto?: ContributorsDTO): Contributors => {
+  return dto?.map(contributorFromDTO) || [];
+};
+
+export const projectContributorFromDTO = (
+  dto: ProjectContributorDTO,
+): ProjectContributor => {
+  return {
+    uuid: dto.uuid,
+    name: dto.name,
+    contributorUuid: dto.contributorUuid,
+    role: dto.role,
+    startDate: new Date(dto.startDate),
+    endDate: new Date(dto.endDate),
+    projectUuid: dto.projectUuid,
+    stageUuid: dto.stageUuid,
+  };
+};
+
+export const projectContributorsFromDTO = (
+  dto?: ProjectContributorsDTO,
+): ProjectContributors => {
+  return dto?.map(projectContributorFromDTO) || [];
+};

package/src/lib/types/editor-content.ts

@@ -0,0 +1,21 @@
+import type { JSONContent } from '@tiptap/core';
+
+/**
+ * TipTap editor content item with 84000-specific attributes.
+ * Used for passage blocks in the translation editor and reader.
+ */
+export type TranslationEditorContentItem = JSONContent & {
+  attrs?: {
+    uuid?: string | null;
+    class?: string | null;
+    type?: string | null;
+    sort?: number | null;
+  };
+};
+
+/**
+ * TipTap editor content - either a single item or array of items.
+ */
+export type TranslationEditorContent =
+  | TranslationEditorContentItem[]
+  | TranslationEditorContentItem;

package/src/lib/types/folio.ts

@@ -0,0 +1,28 @@
+export const FOLIO_SIDES = ['a', 'b'] as const;
+export type FolioSide = (typeof FOLIO_SIDES)[number];
+
+export type FolioDTO = {
+  folio_uuid: string;
+  content: string;
+  volume_number: number;
+  folio_number: number;
+  side: FolioSide;
+};
+
+export type Folio = {
+  uuid: string;
+  content: string;
+  volume: number;
+  folio: number;
+  side: FolioSide;
+};
+
+export const folioFromDTO = (dto: FolioDTO): Folio => {
+  return {
+    uuid: dto.folio_uuid,
+    content: dto.content,
+    volume: dto.volume_number,
+    folio: dto.folio_number,
+    side: dto.side,
+  };
+};