@eightyfourthousand/lib-editing 2026.3.0

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

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { blockquote } from './blockquote';
+
+describe('blockquote exporter', () => {
+  it('should export blockquote annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'blockquote-uuid-1234',
+      },
+      textContent: 'This is a quoted passage from another text.',
+    } as unknown as Node;
+
+    const result = blockquote({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'blockquote-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'blockquote',
+      start: 0,
+      end: 43,
+    });
+  });
+
+  it('should return undefined when textContent is missing', () => {
+    const node = {
+      attrs: {
+        uuid: 'blockquote-uuid-empty',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = blockquote({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/blockquote.ts

@@ -0,0 +1,24 @@
+import { BlockquoteAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const blockquote: Exporter<BlockquoteAnnotation> = ({
+  node,
+  start,
+  passageUuid,
+}): BlockquoteAnnotation | undefined => {
+  const textContent = node.textContent;
+  const uuid = node.attrs.uuid;
+
+  if (!textContent) {
+    console.warn(`Blockquote node ${uuid} is missing body text`);
+    return undefined;
+  }
+
+  return {
+    uuid,
+    type: 'blockquote',
+    passageUuid,
+    start,
+    end: start + textContent.length,
+  };
+};

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

@@ -0,0 +1,93 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { code } from './code';
+
+describe('code exporter', () => {
+  it('should export code annotation correctly', () => {
+    const node = {
+      textContent: 'const x = 1;',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'code-uuid-1234',
+      },
+    } as unknown as Mark;
+
+    const result = code({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'code-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'code',
+      start: 0,
+      end: 12,
+    });
+  });
+
+  it('should use parent textContent when node textContent is missing', () => {
+    const parent = {
+      textContent: 'function test()',
+    } as unknown as Node;
+
+    const node = {
+      textContent: '',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'code-uuid-5678',
+      },
+    } as unknown as Mark;
+
+    const result = code({
+      node,
+      mark,
+      parent,
+      root: parent,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'code-uuid-5678',
+      passageUuid: 'passage-uuid-1234',
+      type: 'code',
+      start: 0,
+      end: 15,
+    });
+  });
+
+  it('should return undefined when textContent is missing', () => {
+    const node = {
+      textContent: '',
+    } as unknown as Node;
+
+    const parent = {
+      textContent: '',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'code-uuid-empty',
+      },
+    } as unknown as Mark;
+
+    const result = code({
+      node,
+      mark,
+      parent,
+      root: parent,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/code.ts

@@ -0,0 +1,26 @@
+import { CodeAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const code: Exporter<CodeAnnotation> = ({
+  node,
+  mark,
+  parent,
+  start,
+  passageUuid,
+}): CodeAnnotation | undefined => {
+  const textContent = node.textContent || parent.textContent || '';
+  const uuid = mark?.attrs.uuid;
+
+  if (!textContent || !uuid) {
+    console.warn(`Code node ${uuid} is missing body text or uuid`);
+    return undefined;
+  }
+
+  return {
+    uuid,
+    type: 'code',
+    passageUuid,
+    start,
+    end: start + textContent.length,
+  };
+};

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

@@ -0,0 +1,104 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { endNoteLink } from './end-note-link';
+
+describe('endNoteLink exporter', () => {
+  it('should export endNoteLink annotations correctly', () => {
+    const node = {
+      textContent: 'text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        notes: [
+          {
+            uuid: 'note-uuid-1',
+            endNote: 'endnote-uuid-1',
+          },
+          {
+            uuid: 'note-uuid-2',
+            endNote: 'endnote-uuid-2',
+          },
+        ],
+      },
+    } as unknown as Mark;
+
+    const result = endNoteLink({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 10,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual([
+      {
+        uuid: 'note-uuid-1',
+        passageUuid: 'passage-uuid-1234',
+        type: 'endNoteLink',
+        start: 14,
+        end: 14,
+        endNote: 'endnote-uuid-1',
+      },
+      {
+        uuid: 'note-uuid-2',
+        passageUuid: 'passage-uuid-1234',
+        type: 'endNoteLink',
+        start: 14,
+        end: 14,
+        endNote: 'endnote-uuid-2',
+      },
+    ]);
+  });
+
+  it('should return empty array when textContent is missing', () => {
+    const node = {
+      textContent: '',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        notes: [
+          {
+            uuid: 'note-uuid-1',
+            endNote: 'endnote-uuid-1',
+          },
+        ],
+      },
+    } as unknown as Mark;
+
+    const result = endNoteLink({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual([]);
+  });
+
+  it('should return empty array when notes are missing', () => {
+    const node = {
+      textContent: 'text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        notes: [],
+      },
+    } as unknown as Mark;
+
+    const result = endNoteLink({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual([]);
+  });
+});

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

@@ -0,0 +1,35 @@
+import { EndNoteLinkAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const endNoteLink: Exporter<EndNoteLinkAnnotation[]> = ({
+  mark,
+  node,
+  start,
+  passageUuid,
+}): EndNoteLinkAnnotation[] => {
+  const textContent = node.textContent;
+  const notes = mark?.attrs.notes || [];
+
+  if (!textContent || notes.length === 0) {
+    console.warn(`Endnote link instance on passage ${passageUuid} incomplete`);
+    return [];
+  }
+
+  const end = start + textContent.length;
+  const annotations: EndNoteLinkAnnotation[] = notes.map(
+    (note: { uuid: string; endNote: string }) => {
+      const { uuid, endNote } = note;
+      return {
+        uuid,
+        type: 'endNoteLink',
+        passageUuid,
+        // end note links are 0-length annotations
+        start: end,
+        end,
+        endNote,
+      };
+    },
+  );
+
+  return annotations;
+};

package/src/lib/exporters/export.ts

@@ -0,0 +1,12 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+
+export type ExporterContext = {
+  passageUuid: string;
+  node: Node;
+  parent: Node;
+  root: Node;
+  start: number;
+  mark?: Mark;
+};
+
+export type Exporter<T> = (ctx: ExporterContext) => T | undefined;

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

@@ -0,0 +1,85 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { glossaryInstance } from './glossary-instance';
+
+describe('glossaryInstance exporter', () => {
+  it('should export glossaryInstance annotation correctly', () => {
+    const node = {
+      textContent: 'Buddha',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'a1b2c3d4-5678-90ab-cdef-1234567890ab',
+        authority: 'f1e2d3c4-5678-90ab-cdef-fedcba098766',
+        glossary: 'f1e2d3c4-5678-90ab-cdef-fedcba098765',
+      },
+    } as unknown as Mark;
+
+    const result = glossaryInstance({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 5,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'a1b2c3d4-5678-90ab-cdef-1234567890ab',
+      authority: 'f1e2d3c4-5678-90ab-cdef-fedcba098766',
+      passageUuid: 'passage-uuid-1234',
+      type: 'glossaryInstance',
+      start: 5,
+      end: 11,
+      glossary: 'f1e2d3c4-5678-90ab-cdef-fedcba098765',
+    });
+  });
+
+  it('should return undefined when textContent is missing', () => {
+    const node = {
+      textContent: '',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'a1b2c3d4-5678-90ab-cdef-1234567890ab',
+        glossary: 'f1e2d3c4-5678-90ab-cdef-fedcba098765',
+        authority: 'f1e2d3c4-5678-90ab-cdef-fedcba098766',
+      },
+    } as unknown as Mark;
+
+    const result = glossaryInstance({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when glossary is missing', () => {
+    const node = {
+      textContent: 'Buddha',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'a1b2c3d4-5678-90ab-cdef-1234567890ab',
+      },
+    } as unknown as Mark;
+
+    const result = glossaryInstance({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,31 @@
+import { GlossaryInstanceAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const glossaryInstance: Exporter<GlossaryInstanceAnnotation> = ({
+  mark,
+  node,
+  start,
+  passageUuid,
+}): GlossaryInstanceAnnotation | undefined => {
+  const textContent = node.textContent;
+  const authority = mark?.attrs.authority;
+  const glossary = mark?.attrs.glossary;
+  const uuid = mark?.attrs.uuid;
+
+  if (!textContent || !glossary || !authority || !uuid) {
+    console.warn(
+      `Glossary instance ${uuid} on pasage ${passageUuid} is incomplete`,
+    );
+    return undefined;
+  }
+
+  return {
+    uuid,
+    type: 'glossaryInstance',
+    passageUuid,
+    start,
+    end: start + textContent.length,
+    authority,
+    glossary,
+  };
+};

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

@@ -0,0 +1,31 @@
+import type { Node } from '@tiptap/pm/model';
+import { hasAbbreviation } from './has-abbreviation';
+
+describe('hasAbbreviation exporter', () => {
+  it('should export hasAbbreviation annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'has-abbr-uuid-1234',
+        abbreviation: 'abbr-ref-uuid-5678',
+      },
+      textContent: 'Toh',
+    } as unknown as Node;
+
+    const result = hasAbbreviation({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'has-abbr-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'hasAbbreviation',
+      start: 0,
+      end: 3,
+      abbreviation: 'abbr-ref-uuid-5678',
+    });
+  });
+});

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

@@ -0,0 +1,21 @@
+import { HasAbbreviationAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const hasAbbreviation: Exporter<HasAbbreviationAnnotation> = ({
+  node,
+  start,
+  passageUuid,
+}): HasAbbreviationAnnotation => {
+  const textContent = node.textContent;
+  const abbreviation = node.attrs.abbreviation;
+  const uuid = node.attrs.uuid;
+
+  return {
+    uuid,
+    type: 'hasAbbreviation',
+    passageUuid,
+    start,
+    end: start + textContent.length,
+    abbreviation,
+  };
+};

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

@@ -0,0 +1,80 @@
+import type { Node } from '@tiptap/pm/model';
+import { heading } from './heading';
+
+describe('heading exporter', () => {
+  it('should export heading annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'heading-uuid-1234',
+        level: 2,
+        class: 'chapter-title',
+      },
+      textContent: 'Chapter Title',
+    } as unknown as Node;
+
+    const result = heading({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'heading-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'heading',
+      start: 0,
+      end: 13,
+      level: 2,
+      class: 'chapter-title',
+    });
+  });
+
+  it('should default to level 1 when level is missing', () => {
+    const node = {
+      attrs: {
+        uuid: 'heading-uuid-5678',
+      },
+      textContent: 'Default Heading',
+    } as unknown as Node;
+
+    const result = heading({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'heading-uuid-5678',
+      passageUuid: 'passage-uuid-1234',
+      type: 'heading',
+      start: 0,
+      end: 15,
+      level: 1,
+      class: undefined,
+    });
+  });
+
+  it('should return undefined when textContent is missing', () => {
+    const node = {
+      attrs: {
+        uuid: 'heading-uuid-empty',
+        level: 1,
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = heading({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/heading.ts

@@ -0,0 +1,28 @@
+import { HeadingAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const heading: Exporter<HeadingAnnotation> = ({
+  node,
+  start,
+  passageUuid,
+}): HeadingAnnotation | undefined => {
+  const textContent = node.textContent;
+  const uuid = node.attrs.uuid;
+  const level = (node.attrs.level as number) || 1;
+  const cls = node.attrs.class;
+
+  if (!textContent) {
+    console.warn(`Heading node ${uuid} is incomplete`);
+    return undefined;
+  }
+
+  return {
+    uuid,
+    type: 'heading',
+    passageUuid,
+    start,
+    end: start + textContent.length,
+    level,
+    class: cls,
+  };
+};

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

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { image } from './image';
+
+describe('image exporter', () => {
+  it('should export image annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'image-uuid-1234',
+        src: '/images/thangka.jpg',
+      },
+    } as unknown as Node;
+
+    const result = image({
+      node,
+      parent: node,
+      root: node,
+      start: 100,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'image-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'image',
+      start: 100,
+      end: 100,
+      src: '/images/thangka.jpg',
+    });
+  });
+
+  it('should return undefined when src is missing', () => {
+    const node = {
+      attrs: {
+        uuid: 'image-uuid-nosrc',
+      },
+    } as unknown as Node;
+
+    const result = image({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/image.ts

@@ -0,0 +1,25 @@
+import { ImageAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const image: Exporter<ImageAnnotation> = ({
+  node,
+  start,
+  passageUuid,
+}): ImageAnnotation | undefined => {
+  const src = node.attrs.src;
+  const uuid = node.attrs.uuid;
+
+  if (!src) {
+    console.warn(`Image node ${uuid} is missing src attribute`);
+    return undefined;
+  }
+
+  return {
+    uuid,
+    type: 'image',
+    passageUuid,
+    start,
+    end: start,
+    src,
+  };
+};