@eightyfourthousand/lib-editing 2026.4.0 → 2026.4.2

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

@@ -1,35 +0,0 @@
-import { HasAbbreviationAnnotation } from '@eightyfourthousand/data-access';
-import { recurse } from './recurse';
-import { splitContent } from './split-content';
-import { Transformer } from './transformer';
-
-export const hasAbbreviation: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const { abbreviation, uuid, start, end } = annotation as HasAbbreviationAnnotation;
-
-  recurse({
-    until: ['text'],
-    ...ctx,
-    transform: (ctx) => {
-      splitContent({
-        ...ctx,
-        transform: ({ block }) => {
-          block.type = 'hasAbbreviation';
-          block.attrs = {
-            ...block.attrs,
-            abbreviation,
-            uuid,
-          };
-          block.content = [
-            {
-              type: 'text',
-              text: block.text,
-              marks: block.marks,
-              attrs: { start, end }
-            },
-          ];
-        },
-      });
-    },
-  });
-};

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

@@ -1,62 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { heading } from './heading';
-import { blockFromPassage } from '../block';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'Chapter Title',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 13,
-      type: 'heading',
-      uuid: 'heading-uuid-1',
-      start: 0,
-      content: [
-        {
-          'heading-level': 'h2',
-        },
-        {
-          'heading-type': 'chapter-title',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('heading 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 heading annotation correctly', () => {
-    // The heading transformer should have already been applied during blockFromPassage
-    // The annotation is applied to the paragraph block inside the passage block
-    expect(block.content).toBeDefined();
-    expect(block.content?.length).toBeGreaterThan(0);
-
-    const paragraphBlock = block.content?.[0];
-    expect(paragraphBlock).toBeDefined();
-    expect(paragraphBlock?.type).toBe('heading');
-    expect(paragraphBlock?.attrs).toBeDefined();
-    expect(paragraphBlock?.attrs?.level).toBe(2);
-    expect(paragraphBlock?.attrs?.class).toBe('chapter-title');
-  });
-});

package/src/lib/transformers/heading.ts

@@ -1,30 +0,0 @@
-import { HeadingAnnotation } from '@eightyfourthousand/data-access';
-import { splitBlock } from './split-block';
-import { Transformer } from './transformer';
-import { recurse } from './recurse';
-
-export const heading: Transformer = ({ root, parent, block, annotation }) => {
-  const heading = annotation as HeadingAnnotation;
-  const level = heading.level || 3;
-  const cls = heading.class;
-
-  recurse({
-    until: ['heading', 'paragraph'],
-    root,
-    parent,
-    block,
-    annotation,
-    transform: (ctx) =>
-      splitBlock({
-        ...ctx,
-        transform: ({ block: item }) => {
-          item.type = 'heading';
-          item.attrs = {
-            ...item.attrs,
-            level,
-            class: cls,
-          };
-        },
-      }),
-  });
-};

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

@@ -1,51 +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: 'See the diagram below.',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 3,
-      type: 'image',
-      uuid: 'image-uuid-1',
-      start: 3,
-      content: [
-        {
-          src: 'https://example.com/image.jpg',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('image 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 image annotation correctly', () => {
-    const imageNode = recurseForType({
-      until: 'image',
-      block,
-    });
-    expect(imageNode).toBeDefined();
-    expect(imageNode?.type).toBe('image');
-    expect(imageNode?.attrs?.src).toBe('https://example.com/image.jpg');
-    expect(imageNode?.attrs?.uuid).toBe('image-uuid-1');
-  });
-});

package/src/lib/transformers/image.ts

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

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

@@ -1,53 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { indent } from './indent';
-import { blockFromPassage } from '../block';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'Indented paragraph text',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 23,
-      type: 'indent',
-      uuid: 'indent-uuid-1',
-      start: 0,
-      content: [],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('indent 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 indent annotation correctly', () => {
-    // The indent annotation is applied to the paragraph block inside the passage block
-    expect(block.content).toBeDefined();
-    expect(block.content?.length).toBeGreaterThan(0);
-
-    const paragraphBlock = block.content?.[0];
-    expect(paragraphBlock).toBeDefined();
-    expect(paragraphBlock?.attrs).toBeDefined();
-    expect(paragraphBlock?.attrs?.hasIndent).toBe(true);
-    expect(paragraphBlock?.attrs?.indentUuid).toBe('indent-uuid-1');
-  });
-});

package/src/lib/transformers/indent.ts

@@ -1,17 +0,0 @@
-import { recurse } from './recurse';
-import { Transformer } from './transformer';
-
-export const indent: Transformer = (ctx) => {
-  const indentUuid = ctx.annotation.uuid;
-  recurse({
-    ...ctx,
-    until: ['paragraph', 'lineGroup', 'list', 'blockquote'],
-    transform: ({ block }) => {
-      block.attrs = {
-        ...block.attrs,
-        hasIndent: true,
-        indentUuid,
-      };
-    },
-  });
-};

package/src/lib/transformers/inline-title.spec.ts

@@ -1,59 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { inlineTitle } from './inline-title';
-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 Dhammapada is a collection of sayings',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 14,
-      type: 'inline-title',
-      uuid: 'inline-title-uuid-1',
-      start: 4,
-      content: [
-        {
-          lang: 'Sa-Ltn',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('inlineTitle 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 inlineTitle annotation correctly', () => {
-    const textNode = findTextNodeWithMarks(block);
-    expect(textNode).toBeDefined();
-    expect(textNode?.type).toBe('text');
-    expect(textNode?.marks).toBeDefined();
-    const italicMark = textNode?.marks?.find((m: any) => m.type === 'italic');
-    expect(italicMark).toBeDefined();
-    expect(italicMark?.attrs?.uuid).toBe('inline-title-uuid-1');
-    expect(italicMark?.attrs?.lang).toBe('Sa-Ltn');
-    expect(italicMark?.attrs?.type).toBe('inlineTitle');
-    expect(textNode?.text).toBe('Dhammapada');
-  });
-});

package/src/lib/transformers/inline-title.ts

@@ -1,34 +0,0 @@
-import { InlineTitleAnnotation } from '@eightyfourthousand/data-access';
-import { Transformer } from './transformer';
-import { splitContent } from './split-content';
-import { ITALIC_LANGUAGES } from './annotate';
-import { recurse } from './recurse';
-
-export const inlineTitle: Transformer = (ctx) => {
-  const { annotation } = ctx;
-
-  const { lang, uuid } = annotation as InlineTitleAnnotation;
-  if (!lang) {
-    return;
-  }
-
-  const markType = ITALIC_LANGUAGES.includes(lang) ? 'italic' : undefined;
-  if (!markType) {
-    return;
-  }
-
-  recurse({
-    ...ctx,
-    until: ['text'],
-    transform: (ctx) =>
-      splitContent({
-        ...ctx,
-        transform: ({ block }) => {
-          block.marks = [
-            ...(block.marks || []),
-            { type: markType, attrs: { uuid, lang, type: 'inlineTitle' } },
-          ];
-        },
-      }),
-  });
-};

package/src/lib/transformers/internal-link.spec.ts

@@ -1,67 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { internalLink } from './internal-link';
-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: 'See the glossary entry',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 22,
-      type: 'internal-link',
-      uuid: 'internal-link-uuid-1',
-      start: 8,
-      content: [
-        {
-          type: 'glossary',
-        },
-        {
-          uuid: 'glossary-entity-uuid',
-        },
-        {
-          href: '#glossary-entry',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('internalLink 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 internalLink annotation correctly', () => {
-    const textNode = findTextNodeWithMarks(block);
-    expect(textNode).toBeDefined();
-    expect(textNode?.type).toBe('text');
-    expect(textNode?.marks).toBeDefined();
-    const internalLinkMark = textNode?.marks?.find(
-      (m: any) => m.type === 'internalLink',
-    );
-    expect(internalLinkMark).toBeDefined();
-    expect(internalLinkMark?.attrs?.uuid).toBe('internal-link-uuid-1');
-    expect(internalLinkMark?.attrs?.type).toBe('glossary');
-    expect(internalLinkMark?.attrs?.entity).toBe('glossary-entity-uuid');
-    expect(textNode?.text).toBe('glossary entry');
-  });
-});

package/src/lib/transformers/internal-link.ts

@@ -1,65 +0,0 @@
-import { InternalLinkAnnotation } from '@eightyfourthousand/data-access';
-import { Transformer } from './transformer';
-import { splitContent } from './split-content';
-import { recurse } from './recurse';
-
-// NOTE: over time, internal links become just regular links.
-export const internalLink: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const {
-    uuid,
-    entity,
-    href = '#',
-    start,
-    end,
-    linkType: type,
-    toh,
-    isSameWork,
-    subtype,
-    linkToh,
-  } = annotation as InternalLinkAnnotation;
-
-  if (!(end - start)) {
-    // If the annotation has no length, we don't need to do anything.
-    console.warn(
-      `Skipping internal link transformation for annotation with no length`,
-      annotation,
-    );
-    return;
-  }
-
-  // NOTE: we use redirects to forward older urls. Hashes aren't passed to the
-  // api, so make an effort to convert them to query params.
-  let path = href.replace('#', '?xmlId=');
-
-  if (type && entity) {
-    path = `/entity/${type}/${entity}`;
-  }
-
-  recurse({
-    ...ctx,
-    until: ['text'],
-    transform: (ctx) =>
-      splitContent({
-        ...ctx,
-        transform: ({ block }) => {
-          block.marks = [
-            ...(block.marks || []),
-            {
-              type: 'internalLink',
-              attrs: {
-                uuid,
-                href: path,
-                entity,
-                type,
-                toh,
-                isSameWork,
-                subtype,
-                linkToh,
-              },
-            },
-          ];
-        },
-      }),
-  });
-};

package/src/lib/transformers/italic.ts

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

package/src/lib/transformers/leading-space.spec.ts

@@ -1,55 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { leadingSpace } from './leading-space';
-import { blockFromPassage } from '../block';
-
-const dto: PassageDTO = {
-  sort: 1,
-  type: 'root',
-  uuid: 'passage-uuid-1234',
-  label: '',
-  xmlId: 'test-passage',
-  parent: 'test-parent',
-  content: 'Paragraph text',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 0,
-      type: 'leading-space',
-      uuid: 'leading-space-uuid-1',
-      start: 0,
-      content: [],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('leadingSpace 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 leadingSpace annotation correctly', () => {
-    // The leadingSpace annotation is applied to the paragraph block inside the passage block
-    expect(block.content).toBeDefined();
-    expect(block.content?.length).toBeGreaterThan(0);
-
-    const paragraphBlock = block.content?.[0];
-    expect(paragraphBlock).toBeDefined();
-    expect(paragraphBlock?.attrs).toBeDefined();
-    expect(paragraphBlock?.attrs?.hasLeadingSpace).toBe(true);
-    expect(paragraphBlock?.attrs?.leadingSpaceUuid).toBe(
-      'leading-space-uuid-1',
-    );
-  });
-});

package/src/lib/transformers/leading-space.ts

@@ -1,17 +0,0 @@
-import { recurse } from './recurse';
-import { Transformer } from './transformer';
-
-export const leadingSpace: Transformer = (ctx) => {
-  const leadingSpaceUuid = ctx.annotation.uuid;
-  recurse({
-    ...ctx,
-    until: ['paragraph', 'lineGroup', 'heading'],
-    transform: ({ block }) => {
-      block.attrs = {
-        ...block.attrs,
-        hasLeadingSpace: true,
-        leadingSpaceUuid,
-      };
-    },
-  });
-};

package/src/lib/transformers/line-group.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: 'A group of verse lines',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 22,
-      type: 'line-group',
-      uuid: 'linegroup-uuid-1',
-      start: 0,
-      content: [],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('lineGroup 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 lineGroup annotation correctly', () => {
-    const lineGroupNode = recurseForType({
-      until: 'lineGroup',
-      block,
-    });
-    expect(lineGroupNode).toBeDefined();
-    expect(lineGroupNode?.type).toBe('lineGroup');
-    expect(lineGroupNode?.attrs?.uuid).toBe('linegroup-uuid-1');
-    expect(lineGroupNode?.content).toBeDefined();
-    expect(lineGroupNode?.content?.[0]?.type).toBe('line');
-  });
-});

package/src/lib/transformers/line-group.ts

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