@eightyfourthousand/data-access 2026.3.0

package/src/lib/types/glossary-page.ts

@@ -0,0 +1,204 @@
+import { removeHtmlTags } from '@eightyfourthousand/lib-utils';
+import { TohokuCatalogEntry } from './toh';
+import {
+  ExtendedTranslationLanguage,
+  displayLanguageForTranslationLanguage,
+} from './language';
+
+export type GlossaryPageLanguage =
+  | 'english'
+  | 'tibetan'
+  | 'sanskrit'
+  | 'pali'
+  | 'chinese';
+
+export type GlossaryLandingItem = {
+  uuid: string;
+  headword: string;
+  type: string;
+  language: string;
+  nameVariants: string;
+  definition: string;
+  numGlossaryEntries: number;
+};
+
+export type LanguageRecord = Record<GlossaryPageLanguage, string[]>;
+
+export type GlossaryDetailItem = LanguageRecord & {
+  authorityUuid: string;
+  headword: string;
+  language: GlossaryPageLanguage;
+  classifications: string[];
+  definition?: string;
+  xmlId?: string;
+};
+
+export type GlossaryPageItem = GlossaryDetailItem & {
+  relatedInstances: GlossaryInstance[];
+  relatedEntities: GlossaryEntity[];
+};
+
+export type GlossaryInstance = LanguageRecord & {
+  workUuid: string;
+  toh: TohokuCatalogEntry;
+  definition?: string;
+  canon?: string;
+  creators: string[];
+};
+
+export type GlossaryEntity = {
+  sourceHeadword: string;
+  sourceUuid: string;
+  targetHeadword: string;
+  targetUuid: string;
+};
+export type GlossaryLandingItemDTO = {
+  authority_uuid: string;
+  headword: string;
+  type: string;
+  headword_language?: ExtendedTranslationLanguage;
+  name_variants?: string;
+  definition?: string;
+  num_glossary_entries?: number;
+};
+
+export type GlossaryDetailDTO = {
+  authority_uuid: string;
+  xmlId?: string;
+  headword: string;
+  headword_language?: GlossaryPageLanguage | null;
+  classifications?: string[] | null;
+  definition?: string | null;
+  tibetan_names?: string[] | null;
+  sanskrit_names?: string[] | null;
+  pali_names?: string[] | null;
+  chinese_names?: string[] | null;
+  english_names?: string[] | null;
+};
+
+export type GlossaryEntityDTO = {
+  related_entity_object_headword: string;
+  related_entity_object_uuid: string;
+  related_entity_subject_headword: string;
+  related_entity_subject_uuid: string;
+};
+
+export type GlossaryInstanceDTO = {
+  glossary_entry_work_uuid: string;
+  glossary_entry_toh: TohokuCatalogEntry;
+  glossary_entry_english?: string | null;
+  glossary_entry_tibetan?: string | null;
+  glossary_entry_sanskrit?: string | null;
+  glossary_entry_chinese?: string | null;
+  glossary_entry_pali?: string | null;
+  glossary_entry_definition?: string | null;
+  glossary_entry_canon?: string | null;
+  glossary_entry_creators?: string[] | null;
+};
+
+export const glossaryLandingItemFromDTO = (
+  dto?: GlossaryLandingItemDTO,
+): GlossaryLandingItem | null => {
+  if (!dto) {
+    return null;
+  }
+
+  const definition = removeHtmlTags(dto.definition || '');
+  const language = dto.headword_language
+    ? displayLanguageForTranslationLanguage(dto.headword_language)
+    : '';
+
+  return {
+    uuid: dto.authority_uuid,
+    headword: dto.headword,
+    type: dto.type.replace('Authority > ', ''),
+    language,
+    nameVariants: dto.name_variants || '',
+    definition,
+    numGlossaryEntries: dto.num_glossary_entries || 0,
+  };
+};
+
+export const glossaryDetailFromDTO = (
+  dto?: GlossaryDetailDTO,
+): GlossaryDetailItem | null => {
+  if (!dto) {
+    return null;
+  }
+
+  return {
+    authorityUuid: dto.authority_uuid,
+    headword: dto.headword,
+    language: dto.headword_language as GlossaryPageLanguage,
+    classifications: dto.classifications || [],
+    definition: dto.definition || undefined,
+    xmlId: dto.xmlId,
+    english: dto.english_names || [],
+    tibetan: dto.tibetan_names || [],
+    sanskrit: dto.sanskrit_names || [],
+    pali: dto.pali_names || [],
+    chinese: dto.chinese_names || [],
+  };
+};
+
+export const glossaryInstanceFromDTO = (
+  dto?: GlossaryInstanceDTO,
+): GlossaryInstance | null => {
+  if (!dto) {
+    return null;
+  }
+
+  return {
+    workUuid: dto.glossary_entry_work_uuid,
+    toh: dto.glossary_entry_toh,
+    definition: dto.glossary_entry_definition || undefined,
+    canon: dto.glossary_entry_canon || undefined,
+    english: dto.glossary_entry_english ? [dto.glossary_entry_english] : [],
+    tibetan: dto.glossary_entry_tibetan ? [dto.glossary_entry_tibetan] : [],
+    sanskrit: dto.glossary_entry_sanskrit ? [dto.glossary_entry_sanskrit] : [],
+    pali: dto.glossary_entry_pali ? [dto.glossary_entry_pali] : [],
+    chinese: dto.glossary_entry_chinese ? [dto.glossary_entry_chinese] : [],
+    creators: dto.glossary_entry_creators || [],
+  };
+};
+
+export const glossaryEntityFromDTO = (
+  dto?: GlossaryEntityDTO,
+): GlossaryEntity | null => {
+  if (!dto) {
+    return null;
+  }
+
+  return {
+    sourceHeadword: dto.related_entity_subject_headword,
+    sourceUuid: dto.related_entity_subject_uuid,
+    targetHeadword: dto.related_entity_object_headword,
+    targetUuid: dto.related_entity_object_uuid,
+  };
+};
+
+export const glossaryPageItemFromDTO = (
+  detail: GlossaryDetailDTO,
+  instances: GlossaryInstanceDTO[],
+  entities: GlossaryEntityDTO[],
+): GlossaryPageItem => {
+  const detailItem = glossaryDetailFromDTO(detail);
+  if (!detailItem) {
+    throw new Error('Invalid glossary detail item');
+  }
+
+  const relatedInstances =
+    instances
+      .map(glossaryInstanceFromDTO)
+      .filter((i): i is GlossaryInstance => i !== null) || [];
+  const relatedEntities =
+    entities
+      .map(glossaryEntityFromDTO)
+      .filter((e): e is GlossaryEntity => e !== null) || [];
+
+  return {
+    ...detailItem,
+    relatedInstances,
+    relatedEntities,
+  };
+};

package/src/lib/types/glossary.ts

@@ -0,0 +1,114 @@
+
+export type GlossaryItem = {
+  authorityUuid: string;
+  definition?: string | null;
+  names: GlossaryNames;
+  nameUuid?: string;
+};
+
+export type Glossary = GlossaryItem[];
+
+export type GlossaryName = {
+  content: string;
+  definition?: string | null;
+  nameUuid: string;
+};
+
+export type GlossaryNames = GlossaryName[];
+
+export type GlossaryItemDTO = {
+  authority_uuid: string;
+  definition?: string | null;
+  names: GlossaryNamesDTO;
+  name_uuid: string;
+};
+
+export type GlossaryDTO = GlossaryItemDTO[];
+
+export type GlossaryNameDTO = {
+  content: string;
+  definition?: string | null;
+  name_uuid: string;
+};
+
+export type GlossaryNamesDTO = GlossaryNameDTO[];
+
+export type GlossaryTermInstance = {
+  uuid: string;
+  authority: string;
+  workUuid: string;
+  definition?: string | null;
+  termNumber: number;
+  names: {
+    chinese?: string;
+    english?: string;
+    pali?: string;
+    sanskrit?: string;
+    tibetan?: string;
+    wylie?: string;
+  };
+  passages?: {
+    items: Array<{ uuid: string; type: string; label: string }>;
+    nextCursor: string | null;
+    hasMore: boolean;
+  }
+};
+
+export type GlossaryTermInstances = GlossaryTermInstance[];
+
+export type GlossaryTermInstanceDTO = {
+  uuid: string;
+  authority_uuid: string;
+  work_uuid: string;
+  definition?: string;
+  names: {
+    chinese?: string;
+    english?: string;
+    pali?: string;
+    sanskrit?: string;
+    tibetan?: string;
+    wylie?: string;
+  };
+};
+
+export type GlossaryTermInstancesDTO = {
+  work_uuid: string;
+  glossary_entries: GlossaryTermInstanceDTO[];
+};
+
+export const glossaryNameFromDTO = (dto: GlossaryNameDTO): GlossaryName => {
+  return {
+    content: dto.content,
+    definition: dto.definition,
+    nameUuid: dto.name_uuid,
+  };
+};
+
+export const glossaryNamesFromDTO = (dto?: GlossaryNamesDTO): GlossaryNames => {
+  return dto?.map(glossaryNameFromDTO) || [];
+};
+
+export const glossaryItemFromDTO = (dto: GlossaryItemDTO): GlossaryItem => {
+  return {
+    authorityUuid: dto.authority_uuid,
+    definition: dto.definition,
+    names: glossaryNamesFromDTO(dto.names),
+    nameUuid: dto.name_uuid,
+  };
+};
+export const glossaryFromDTO = (dto?: GlossaryDTO): Glossary => {
+  return dto?.map(glossaryItemFromDTO) || [];
+};
+
+export const glossaryTermInstanceFromDTO = (
+  dto: GlossaryTermInstanceDTO,
+): GlossaryTermInstance => {
+  return {
+    uuid: dto.uuid,
+    authority: dto.authority_uuid,
+    workUuid: dto.work_uuid,
+    definition: dto.definition,
+    termNumber: 0,
+    names: dto.names,
+  };
+};

package/src/lib/types/imprint.ts

@@ -0,0 +1,159 @@
+import { TranslationLanguage } from './language';
+import { BACK_MATTER, BODY_MATTER, FRONT_MATTER } from './passage';
+import { SemVer } from './semver';
+
+export type Imprint = {
+  uuid: string;
+  toh: string;
+  section?: string;
+  version?: SemVer;
+  restriction?: boolean;
+  publishYear?: string;
+  tibetanAuthors?: string[];
+  isAuthorContested: boolean;
+  sourceDescription?: string;
+  publisherStatement?: string;
+  tibetanTranslators?: string;
+  license: {
+    link?: string;
+    name?: string;
+    description?: string;
+  };
+  mainTitles?: Partial<{ [key in TranslationLanguage]: string }>;
+  longTitles?: Partial<{ [key in TranslationLanguage]: string }>;
+};
+
+export type ImprintDTO = {
+  work_uuid: string;
+  toh: string;
+  section?: string;
+  version?: SemVer;
+  restriction?: boolean;
+  publishYear?: string;
+  tibetanAuthors?: string;
+  isAuthorContested?: boolean;
+  sourceDescription?: string;
+  publisherStatement?: string;
+  tibetanTranslators?: string;
+  license: {
+    link?: string;
+    name?: string;
+    description?: string;
+  };
+  mainTitles?: Partial<{ [key in TranslationLanguage]: string }>;
+  longTitles?: Partial<{ [key in TranslationLanguage]: string }>;
+};
+
+export const imprintFromDTO = (dto: ImprintDTO): Imprint => {
+  return {
+    uuid: dto.work_uuid,
+    toh: dto.toh,
+    section: dto.section,
+    version: dto.version,
+    restriction: dto.restriction,
+    publishYear: dto.publishYear,
+    tibetanAuthors: dto.tibetanAuthors
+      ?.split(',')
+      .map((author) => author.trim())
+      .filter((author) => author.length > 0),
+    isAuthorContested: dto.isAuthorContested || false,
+    sourceDescription: dto.sourceDescription,
+    publisherStatement: dto.publisherStatement,
+    tibetanTranslators: dto.tibetanTranslators,
+    license: {
+      ...dto.license,
+    },
+    mainTitles: dto.mainTitles,
+    longTitles: dto.longTitles,
+  };
+};
+
+const ALL_SECTIONS = [...FRONT_MATTER, ...BODY_MATTER, ...BACK_MATTER];
+export type TranslationSection = (typeof ALL_SECTIONS)[number];
+
+export type TocEntryDTO = {
+  uuid: string;
+  content: string;
+  label?: string;
+  sort: number;
+  section: TranslationSection;
+  level: number;
+};
+
+export type TocDTO = TocEntryDTO[];
+
+export type TocEntry = {
+  uuid: string;
+  content: string;
+  label?: string;
+  sort: number;
+  level: number;
+  section: TranslationSection;
+  children: TocEntry[];
+};
+
+export type Toc = {
+  frontMatter: TocEntry[];
+  body: TocEntry[];
+  backMatter: TocEntry[];
+};
+
+export const tocFromDTO = (dto: TocDTO): Toc => {
+  // map by front matter, body matter, back matter based on constants above
+  const frontMatter: TocEntry[] = [];
+  const bodyMatter: TocEntry[] = [];
+  const backMatter: TocEntry[] = [];
+
+  const sectionMap: { [key in TranslationSection]: TocEntry[] } = {
+    abbreviations: backMatter,
+    acknowledgment: frontMatter,
+    appendix: bodyMatter,
+    colophon: bodyMatter,
+    endnotes: backMatter,
+    homage: bodyMatter,
+    introduction: frontMatter,
+    prelude: bodyMatter,
+    prologue: bodyMatter,
+    summary: frontMatter,
+    translation: bodyMatter,
+  };
+
+  dto.forEach((entry) => {
+    const tocEntry: TocEntry = {
+      ...entry,
+      children: [],
+    };
+    sectionMap[entry.section].push(tocEntry);
+  });
+
+  // within each section, create a hierarchy based on level from low to high
+  const buildHierarchy = (entries: TocEntry[]): TocEntry[] => {
+    const root: TocEntry = {
+      uuid: 'root',
+      content: '',
+      sort: 0,
+      level: 0,
+      section: 'introduction',
+      children: [],
+    };
+    const stack: TocEntry[] = [root];
+
+    entries.sort((a, b) => a.sort - b.sort);
+
+    entries.forEach((entry) => {
+      while (stack.length > 1 && entry.level <= stack[stack.length - 1].level) {
+        stack.pop();
+      }
+      stack[stack.length - 1].children.push(entry);
+      stack.push(entry);
+    });
+
+    return root.children;
+  };
+
+  return {
+    frontMatter: buildHierarchy(frontMatter),
+    body: buildHierarchy(bodyMatter),
+    backMatter: buildHierarchy(backMatter),
+  };
+};

package/src/lib/types/index.ts

@@ -0,0 +1,22 @@
+export * from './alignment';
+export * from './annotation';
+export * from './bibliography';
+export * from './canon';
+export * from './client';
+export * from './contributor';
+export * from './editor-content';
+export * from './toh';
+export * from './folio';
+export * from './glossary';
+export * from './glossary-page';
+export * from './imprint';
+export * from './language';
+export * from './layout';
+export * from './library';
+export * from './passage';
+export * from './project';
+export * from './semver';
+export * from './title';
+export * from './translation';
+export * from './user';
+export * from './work';

package/src/lib/types/language.ts

@@ -0,0 +1,64 @@
+export const LANGUAGES = ['bo', 'en', 'Bo-Ltn', 'Sa-Ltn'] as const;
+export type TranslationLanguage = (typeof LANGUAGES)[number];
+export type ExtendedTranslationLanguage =
+  | TranslationLanguage
+  | 'zh'
+  | 'ja'
+  | 'Mt-Ltn'
+  | 'Pi-Ltn'
+  | 'Zh-Ltn';
+
+export const DISPLAY_LANGUAGES = [
+  'tibetan',
+  'english',
+  'wylie',
+  'sanskrit',
+  'chinese',
+  'japanese',
+  'mongolian',
+  'pali',
+  'pinyin',
+] as const;
+export type DisplayLanguage = (typeof DISPLAY_LANGUAGES)[number];
+
+export const LANGUAGE_MAP: Record<
+  ExtendedTranslationLanguage,
+  DisplayLanguage
+> = {
+  bo: 'tibetan',
+  en: 'english',
+  'Bo-Ltn': 'tibetan',
+  'Sa-Ltn': 'sanskrit',
+  zh: 'chinese',
+  ja: 'japanese',
+  'Mt-Ltn': 'mongolian',
+  'Pi-Ltn': 'pali',
+  'Zh-Ltn': 'pinyin',
+};
+
+export const REVERSE_LANGUAGE_MAP: Record<
+  DisplayLanguage,
+  ExtendedTranslationLanguage
+> = {
+  tibetan: 'bo',
+  english: 'en',
+  wylie: 'Bo-Ltn',
+  sanskrit: 'Sa-Ltn',
+  chinese: 'zh',
+  japanese: 'ja',
+  mongolian: 'Mt-Ltn',
+  pinyin: 'Zh-Ltn',
+  pali: 'Pi-Ltn',
+};
+
+export const displayLanguageForTranslationLanguage = (
+  language: ExtendedTranslationLanguage,
+): DisplayLanguage => {
+  return LANGUAGE_MAP[language];
+};
+
+export const translationLanguageForDisplayLanguage = (
+  language: DisplayLanguage,
+): ExtendedTranslationLanguage => {
+  return REVERSE_LANGUAGE_MAP[language];
+};

package/src/lib/types/layout.ts

@@ -0,0 +1,37 @@
+import { BodyItemType } from './passage';
+
+export type PanelContentType =
+  | BodyItemType
+  | 'glossary'
+  | 'bibliography'
+  | 'source';
+
+// NOTE: default to 'translation' (or 'compare') for content types not listed here
+export const TAB_FOR_CONTENT_SECTION: Partial<
+  Record<PanelContentType, string>
+> = {
+  abbreviations: 'abbreviations',
+  acknowledgment: 'front',
+  bibliography: 'bibliography',
+  glossary: 'glossary',
+  endnotes: 'endnotes',
+  introduction: 'front',
+  summary: 'front',
+} as const;
+
+// NOTE: default to 'main' for content types not listed here
+export const PANEL_FOR_CONTENT_SECTION: Partial<
+  Record<PanelContentType, string>
+> = {
+  abbreviations: 'right',
+  bibliography: 'right',
+  endnotes: 'right',
+  glossary: 'right',
+  source: 'main',
+} as const;
+
+// Support different tabs for some content
+export const VARIANT_TABS_FOR_TAB: Partial<Record<PanelContentType, string[]>> =
+  {
+    translation: ['compare'],
+  } as const;

package/src/lib/types/library.ts

@@ -0,0 +1,29 @@
+export const LIBRARY_ITEMS = [
+  'publications',
+  'passages',
+  'glossaries',
+  'bibliographies',
+  'searches',
+] as const;
+
+export type LibraryItemType = (typeof LIBRARY_ITEMS)[number];
+
+export type UserLibraryItem = {
+  uuid: string;
+  type: LibraryItemType;
+  createdAt: string;
+  featured: boolean;
+};
+
+export type UserPassageWork = {
+  uuid: string;
+  toh: string;
+};
+
+export type UserPassageItem = {
+  uuid: string;
+  toh: string;
+  label: string;
+  content: string;
+  work: UserPassageWork;
+};