@eightyfourthousand/lib-editing 2026.4.0 → 2026.4.2

package/src/lib/transformers/annotate.ts

@@ -1,146 +0,0 @@
-import {
-  AnnotationType,
-  Annotations,
-  ExtendedTranslationLanguage,
-} from '@eightyfourthousand/data-access';
-import type { TranslationEditorContentType, Transformer } from './transformer';
-import {
-  audio,
-  abbreviation,
-  blockquote,
-  code,
-  deprecated,
-  endNoteLink,
-  glossaryInstance,
-  hasAbbreviation,
-  heading,
-  image,
-  indent,
-  inlineTitle,
-  internalLink,
-  leadingSpace,
-  lineGroup,
-  line,
-  link,
-  list,
-  listItem,
-  mantra,
-  mention,
-  paragraph,
-  quote,
-  quoted,
-  reference,
-  span,
-  table,
-  tableBodyData,
-  tableBodyHeader,
-  tableBodyRow,
-  trailer,
-  unknown,
-} from '.';
-import type { TranslationEditorContentItem } from '../components/editor';
-
-const TRANSFORMERS: Partial<Record<AnnotationType, Transformer>> = {
-  abbreviation,
-  audio,
-  blockquote,
-  code,
-  deprecated,
-  endNoteLink,
-  glossaryInstance,
-  hasAbbreviation,
-  heading,
-  indent,
-  image,
-  inlineTitle,
-  internalLink,
-  leadingSpace,
-  line,
-  lineGroup,
-  link,
-  list,
-  listItem,
-  mantra,
-  mention,
-  paragraph,
-  quote,
-  quoted,
-  reference,
-  span,
-  table,
-  tableBodyData,
-  tableBodyHeader,
-  tableBodyRow,
-  trailer,
-  unknown,
-} as const;
-
-export const ITALIC_LANGUAGES: ExtendedTranslationLanguage[] = [
-  'en',
-  'Bo-Ltn',
-  'Mt-Ltn',
-  'Pi-Ltn',
-  'Sa-Ltn',
-  'Zh-Ltn',
-] as const;
-
-export const isAttributeAnnotation = (type: TranslationEditorContentType) => {
-  return ['indent', 'leadingSpace'].includes(type);
-};
-
-export const isBlockAnnotation = (type: TranslationEditorContentType) => {
-  return [
-    'blockquote',
-    'endnotes',
-    'heading',
-    'line',
-    'lineGroup',
-    'list',
-    'listItem',
-    'paragraph',
-    'table',
-    'tableBodyData',
-    'tableBodyHeader',
-    'tableBodyRow',
-    'trailer',
-  ].includes(type);
-};
-
-export const isInlineAnnotation = (type: TranslationEditorContentType) => {
-  return [
-    'abbreviation',
-    'audio',
-    'code',
-    'endNoteLink',
-    'glossaryInstance',
-    'hasAbbreviation',
-    'image',
-    'italic',
-    'inlineTitle',
-    'internalLink',
-    'link',
-    'mantra',
-    'mention',
-    'quote',
-    'quoted',
-    'reference',
-    'span',
-    'text',
-  ].includes(type);
-};
-
-export const annotateBlock = (
-  block: TranslationEditorContentItem,
-  annotations: Annotations,
-) => {
-  for (const annotation of annotations) {
-    const transformer = TRANSFORMERS[annotation.type] || TRANSFORMERS.unknown;
-    transformer?.({ root: block, block, annotation });
-    if (!annotation.validated) {
-      if (!block.attrs) {
-        block.attrs = {};
-      }
-      block.attrs.invalid = true;
-    }
-  }
-};

package/src/lib/transformers/audio.spec.ts

@@ -1,55 +0,0 @@
-import { annotationsFromDTO, PassageDTO, passageFromDTO } from '@eightyfourthousand/data-access';
-import { blockFromPassage } from '../block';
-import { recurseForType } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'Listen to the audio recording.',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 9,
-      type: 'audio',
-      uuid: 'audio-uuid-1',
-      start: 9,
-      content: [
-        {
-          src: 'https://example.com/audio.mp3',
-        },
-        {
-          'media-type': 'audio/mpeg',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('audio transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || [], dto.content.length),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform audio annotation correctly', () => {
-    const audioNode = recurseForType({
-      until: 'audio',
-      block,
-    });
-    expect(audioNode).toBeDefined();
-    expect(audioNode?.type).toBe('audio');
-    expect(audioNode?.attrs?.src).toBe('https://example.com/audio.mp3');
-    expect(audioNode?.attrs?.mediaType).toBe('audio/mpeg');
-    expect(audioNode?.attrs?.uuid).toBe('audio-uuid-1');
-  });
-});

package/src/lib/transformers/audio.ts

@@ -1,29 +0,0 @@
-import { AudioAnnotation } from '@eightyfourthousand/data-access';
-import { Transformer } from './transformer';
-import { recurse } from './recurse';
-import { splitAndInsert } from './split-insert';
-
-export const audio: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const { src, mediaType, uuid, start, end } = annotation as AudioAnnotation;
-  recurse({
-    ...ctx,
-    until: ['paragraph'],
-    transform: (ctx) => {
-      splitAndInsert({
-        ...ctx,
-        transform: ({ block }) => {
-          block.type = 'audio';
-          block.attrs = {
-            ...block.attrs,
-            src,
-            mediaType,
-            uuid,
-            start,
-            end,
-          };
-        },
-      });
-    },
-  });
-};

package/src/lib/transformers/blockquote.spec.ts

@@ -1,48 +0,0 @@
-import { annotationsFromDTO, PassageDTO, passageFromDTO } from '@eightyfourthousand/data-access';
-import { blockFromPassage } from '../block';
-import { recurseForType } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'This is a quoted text from scripture.',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 37,
-      type: 'blockquote',
-      uuid: 'blockquote-uuid-1',
-      start: 0,
-      content: [],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('blockquote transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || [], dto.content.length),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform blockquote annotation correctly', () => {
-    const blockquoteNode = recurseForType({
-      until: 'blockquote',
-      block,
-    });
-    expect(blockquoteNode).toBeDefined();
-    expect(blockquoteNode?.type).toBe('blockquote');
-    expect(blockquoteNode?.attrs?.uuid).toBe('blockquote-uuid-1');
-    expect(blockquoteNode?.content).toBeDefined();
-    expect(blockquoteNode?.content?.[0]?.type).toBe('paragraph');
-  });
-});

package/src/lib/transformers/blockquote.ts

@@ -1,41 +0,0 @@
-import { recurse } from './recurse';
-import { splitBlock } from './split-block';
-import { Transformer } from './transformer';
-
-export const blockquote: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const { start, end, uuid } = annotation || {};
-
-  recurse({
-    ...ctx,
-    until: ['paragraph', 'lineGroup'],
-    transform: (ctx) => {
-      const origType = ctx.block?.type || 'paragraph';
-      splitBlock({
-        ...ctx,
-        transform: (ctx) => {
-          const { block } = ctx;
-          block.type = 'blockquote';
-          block.attrs = {
-            ...block.attrs,
-            start,
-            end,
-            uuid,
-          };
-          block.content = [
-            {
-              type: origType,
-              attrs: {
-                ...block.attrs,
-                start,
-                end,
-                uuid,
-              },
-              content: block.content || [],
-            },
-          ];
-        },
-      });
-    },
-  });
-};

package/src/lib/transformers/code.spec.ts

@@ -1,52 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { code } from './code';
-import { blockFromPassage } from '../block';
-import { findTextNodeWithMarks } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'Some code text here',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 14,
-      type: 'code',
-      uuid: 'code-uuid-1',
-      start: 5,
-      content: [],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('code transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || [], dto.content.length),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform code annotation correctly', () => {
-    const textNode = findTextNodeWithMarks(block);
-    expect(textNode).toBeDefined();
-    expect(textNode?.type).toBe('text');
-    expect(textNode?.marks).toBeDefined();
-    const codeMark = textNode?.marks?.find((m: any) => m.type === 'code');
-    expect(codeMark).toBeDefined();
-    expect(textNode?.text).toBe('code text');
-  });
-});

package/src/lib/transformers/code.ts

@@ -1,22 +0,0 @@
-import type { Transformer } from './transformer';
-import { splitContent } from './split-content';
-import { recurse } from './recurse';
-
-export const code: Transformer = (ctx) => {
-  recurse({
-    ...ctx,
-    until: ['text'],
-    transform: (ctx) =>
-      splitContent({
-        ...ctx,
-        transform: ({ block }) => {
-          block.marks = [
-            ...(block.marks || []),
-            {
-              type: 'code',
-            },
-          ];
-        },
-      }),
-  });
-};

package/src/lib/transformers/deprecated.ts

@@ -1,7 +0,0 @@
-import { Transformer } from './transformer';
-
-export const deprecated: Transformer = ({ block, annotation }) => {
-  console.warn(
-    `Deprecated annotation type ${annotation.type} in block ${block.uuid}`,
-  );
-};

package/src/lib/transformers/end-note-link.spec.ts

@@ -1,56 +0,0 @@
-import { annotationsFromDTO, PassageDTO, passageFromDTO } from '@eightyfourthousand/data-access';
-import { blockFromPassage } from '../block';
-import { findTextNodeWithMarks } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'Some text',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 9,
-      type: 'end-note-link',
-      uuid: 'endnote-link-uuid-1',
-      start: 9,
-      content: [
-        {
-          uuid: 'endnote-uuid-1',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('endNoteLink transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || [], dto.content.length),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform endNoteLink annotation correctly', () => {
-    // Transformers are applied automatically in blockFromPassage
-    const textNode = findTextNodeWithMarks(block);
-    expect(textNode).toBeDefined();
-    expect(textNode?.type).toBe('text');
-    expect(textNode?.marks).toBeDefined();
-    const endnoteMark = textNode?.marks?.find(
-      (m: any) => m.type === 'endNoteLink',
-    );
-    expect(endnoteMark).toBeDefined();
-    expect(endnoteMark?.attrs?.notes).toBeDefined();
-    expect(endnoteMark?.attrs?.notes?.length).toBe(1);
-    expect(endnoteMark?.attrs?.notes?.[0].endNote).toBe('endnote-uuid-1');
-    expect(endnoteMark?.attrs?.notes?.[0].uuid).toBe('endnote-link-uuid-1');
-  });
-});

package/src/lib/transformers/end-note-link.ts

@@ -1,76 +0,0 @@
-import { EndNoteLinkAnnotation } from '@eightyfourthousand/data-access';
-import { Transformer } from './transformer';
-import { recurse } from './recurse';
-import { splitContentAt } from './split-at';
-import { splitContent } from './split-content';
-
-const innerTransform: Transformer = ({ block, annotation }) => {
-  const { endNote, label, uuid, start, end, toh } =
-    annotation as EndNoteLinkAnnotation;
-  let endnoteMark = block.marks?.find((m) => m.type === 'endNoteLink');
-  const marks = block.marks || [];
-  const notes = endnoteMark?.attrs?.notes || [];
-  notes.push({
-    endNote,
-    label,
-    uuid,
-    start,
-    end,
-    location: end === 0 ? 'start' : 'end',
-    toh,
-  });
-
-  if (endnoteMark) {
-    endnoteMark.attrs = endnoteMark.attrs || {};
-    endnoteMark.attrs.notes = notes;
-  } else {
-    endnoteMark = {
-      type: 'endNoteLink',
-      attrs: {
-        notes,
-      },
-    };
-    marks.push(endnoteMark);
-  }
-
-  block.marks = [...marks];
-};
-
-export const endNoteLink: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const { endNote, uuid, end } = annotation as EndNoteLinkAnnotation;
-
-  if (!endNote) {
-    console.warn(`End note link ${uuid} is missing end note reference`);
-    return;
-  }
-
-  const isStart = end === 0;
-
-  recurse({
-    ...ctx,
-    until: ['text'],
-    transform: (ctx) => {
-      if (isStart) {
-        splitContent({
-          ...ctx,
-          annotation: {
-            ...annotation,
-            end: 1,
-          },
-          transform: ({ block }) => {
-            innerTransform({ ...ctx, block });
-          },
-        });
-        return;
-      }
-
-      splitContentAt({
-        ...ctx,
-        transform: ({ block }) => {
-          innerTransform({ ...ctx, block });
-        },
-      });
-    },
-  });
-};

package/src/lib/transformers/glossary-instance.spec.ts

@@ -1,55 +0,0 @@
-import { annotationsFromDTO, PassageDTO, passageFromDTO } from '@eightyfourthousand/data-access';
-import { blockFromPassage } from '../block';
-import { findTextNodeWithMarks } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'The Buddha taught the Dharma.',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 10,
-      type: 'glossary-instance',
-      uuid: 'glossary-instance-uuid-1',
-      start: 4,
-      content: [
-        {
-          uuid: 'glossary-entry-uuid-1',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('glossaryInstance transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || [], dto.content.length),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform glossaryInstance annotation correctly', () => {
-    // Transformers are applied automatically in blockFromPassage
-    const textNode = findTextNodeWithMarks(block);
-    expect(textNode).toBeDefined();
-    expect(textNode?.type).toBe('text');
-    expect(textNode?.marks).toBeDefined();
-    const glossaryMark = textNode?.marks?.find(
-      (m: any) => m.type === 'glossaryInstance',
-    );
-    expect(glossaryMark).toBeDefined();
-    expect(glossaryMark?.attrs?.glossary).toBe('glossary-entry-uuid-1');
-    expect(glossaryMark?.attrs?.uuid).toBe('glossary-instance-uuid-1');
-    expect(textNode?.text).toBe('Buddha');
-  });
-});

package/src/lib/transformers/glossary-instance.ts

@@ -1,40 +0,0 @@
-import { GlossaryInstanceAnnotation } from '@eightyfourthousand/data-access';
-import { Transformer } from './transformer';
-import { recurse } from './recurse';
-import { splitContent } from './split-content';
-
-export const glossaryInstance: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const { uuid, glossary, authority, toh } = annotation as GlossaryInstanceAnnotation;
-
-  if (!glossary) {
-    console.warn(`Glossary instance ${uuid} is missing glossary UUID`);
-
-    return;
-  }
-
-  recurse({
-    ...ctx,
-    until: ['text'],
-    transform: (ctx) => {
-      splitContent({
-        ...ctx,
-        transform: (ctx) => {
-          const { block } = ctx;
-          block.marks = [
-            ...(block.marks || []),
-            {
-              type: 'glossaryInstance',
-              attrs: {
-                authority,
-                glossary,
-                uuid,
-                toh,
-              },
-            },
-          ];
-        },
-      });
-    },
-  });
-};

package/src/lib/transformers/has-abbreviation.spec.ts

@@ -1,50 +0,0 @@
-import { annotationsFromDTO, PassageDTO, passageFromDTO } from '@eightyfourthousand/data-access';
-import { blockFromPassage } from '../block';
-import { recurseForType } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'The 84000 project translates Tibetan texts.',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 10,
-      type: 'has-abbreviation',
-      uuid: 'has-abbr-uuid-1',
-      start: 4,
-      content: [
-        {
-          uuid: 'abbr-uuid-1',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('hasAbbreviation transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || [], dto.content.length),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform hasAbbreviation annotation correctly', () => {
-    const hasAbbrNode = recurseForType({ block, until: 'hasAbbreviation' });
-    expect(hasAbbrNode).toBeDefined();
-    expect(hasAbbrNode?.type).toBe('hasAbbreviation');
-    expect(hasAbbrNode?.attrs?.abbreviation).toBe('abbr-uuid-1');
-    expect(hasAbbrNode?.attrs?.uuid).toBe('has-abbr-uuid-1');
-    expect(hasAbbrNode?.content?.[0]?.type).toBe('text');
-    expect(hasAbbrNode?.content?.[0]?.text).toBe('84000 ');
-  });
-});