@eightyfourthousand/lib-editing 2026.3.0

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

@@ -0,0 +1,118 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { span } from './span';
+
+describe('span exporter', () => {
+  it('should export bold span annotation correctly', () => {
+    const node = {
+      textContent: 'bold text',
+    } as unknown as Node;
+
+    const mark = {
+      type: { name: 'bold' },
+      attrs: {
+        uuid: 'span-uuid-1234',
+      },
+    } as unknown as Mark;
+
+    const result = span({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'span-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'span',
+      start: 0,
+      end: 9,
+      textStyle: 'text-bold',
+      lang: undefined,
+    });
+  });
+
+  it('should export smallCaps span annotation correctly', () => {
+    const node = {
+      textContent: 'small caps',
+    } as unknown as Node;
+
+    const mark = {
+      type: { name: 'smallCaps' },
+      attrs: {
+        uuid: 'span-uuid-5678',
+      },
+    } as unknown as Mark;
+
+    const result = span({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 5,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'span-uuid-5678',
+      passageUuid: 'passage-uuid-1234',
+      type: 'span',
+      start: 5,
+      end: 15,
+      textStyle: 'small-caps',
+      lang: undefined,
+    });
+  });
+
+  it('should export span with language', () => {
+    const node = {
+      textContent: 'text',
+    } as unknown as Node;
+
+    const mark = {
+      type: { name: 'bold' },
+      attrs: {
+        uuid: 'span-uuid-lang',
+        lang: 'bo',
+      },
+    } as unknown as Mark;
+
+    const result = span({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'span-uuid-lang',
+      passageUuid: 'passage-uuid-1234',
+      type: 'span',
+      start: 0,
+      end: 4,
+      textStyle: 'text-bold',
+      lang: 'bo',
+    });
+  });
+
+  it('should return undefined when mark is missing', () => {
+    const node = {
+      textContent: 'text',
+    } as unknown as Node;
+
+    const result = span({
+      node,
+      mark: undefined,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/span.ts

@@ -0,0 +1,44 @@
+import { ExtendedTranslationLanguage, SpanAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter, ExporterContext } from './export';
+import { SpanMarkType } from '../types';
+
+const SPAN_TYPE_FOR_MARK_TYPE: {
+  [key in SpanMarkType]: string;
+} = {
+  bold: 'text-bold',
+  smallCaps: 'small-caps',
+  subscript: 'subscript',
+  superscript: 'superscript',
+  underline: 'underline',
+};
+
+export const span: Exporter<SpanAnnotation> = ({
+  mark,
+  node,
+  parent,
+  start,
+  passageUuid,
+}: ExporterContext): SpanAnnotation | undefined => {
+  if (!mark) {
+    console.warn('Span exporter called without mark');
+    return undefined;
+  }
+
+  const uuid = mark?.attrs.uuid;
+
+  const textContent = node.textContent || parent.textContent || '';
+  const end = start + textContent.length;
+  const markType = mark.type.name as SpanMarkType;
+  const lang = mark?.attrs.lang as ExtendedTranslationLanguage;
+  const textStyle = SPAN_TYPE_FOR_MARK_TYPE[markType] || mark.attrs.textStyle;
+
+  return {
+    uuid,
+    type: 'span',
+    passageUuid,
+    start,
+    end,
+    textStyle,
+    lang,
+  } as SpanAnnotation;
+};

package/src/lib/exporters/table-body-data.spec.ts

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { tableBodyData } from './table-body-data';
+
+describe('tableBodyData exporter', () => {
+  it('should export tableBodyData annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-data-uuid-1234',
+      },
+      textContent: 'Table cell content',
+    } as unknown as Node;
+
+    const result = tableBodyData({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'table-data-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'tableBodyData',
+      start: 0,
+      end: 18,
+    });
+  });
+
+  it('should return undefined when textContent is empty', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-data-uuid-empty',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = tableBodyData({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/table-body-data.ts

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

package/src/lib/exporters/table-body-header.spec.ts

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { tableBodyHeader } from './table-body-header';
+
+describe('tableBodyHeader exporter', () => {
+  it('should export tableBodyHeader annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-header-uuid-1234',
+      },
+      textContent: 'Header Cell',
+    } as unknown as Node;
+
+    const result = tableBodyHeader({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'table-header-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'tableBodyHeader',
+      start: 0,
+      end: 11,
+    });
+  });
+
+  it('should return undefined when textContent is empty', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-header-uuid-empty',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = tableBodyHeader({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/table-body-header.ts

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

package/src/lib/exporters/table-body-row.spec.ts

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { tableBodyRow } from './table-body-row';
+
+describe('tableBodyRow exporter', () => {
+  it('should export tableBodyRow annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-row-uuid-1234',
+      },
+      textContent: 'Cell 1\tCell 2\tCell 3',
+    } as unknown as Node;
+
+    const result = tableBodyRow({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'table-row-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'tableBodyRow',
+      start: 0,
+      end: 20,
+    });
+  });
+
+  it('should return undefined when textContent is empty', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-row-uuid-empty',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = tableBodyRow({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/table-body-row.ts

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

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

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { table } from './table';
+
+describe('table exporter', () => {
+  it('should export table annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-uuid-1234',
+      },
+      textContent: 'Cell 1\tCell 2\nCell 3\tCell 4',
+    } as unknown as Node;
+
+    const result = table({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'table-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'table',
+      start: 0,
+      end: 27,
+    });
+  });
+
+  it('should return undefined when textContent is empty', () => {
+    const node = {
+      attrs: {
+        uuid: 'table-uuid-empty',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = table({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/table.ts

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

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

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

package/src/lib/exporters/trailer.ts

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

package/src/lib/exporters/util.ts

@@ -0,0 +1,62 @@
+import { Node, Mark } from '@tiptap/pm/model';
+
+export const findNodePosition = (
+  parent: Node,
+  uuid: string,
+  type: string,
+): number | undefined => {
+  let textOffset = 0;
+  let targetFound = false;
+
+  const traverse = (node: Node): boolean => {
+    if (node.attrs?.uuid === uuid && node.type.name === type) {
+      targetFound = true;
+      return true;
+    }
+
+    if (node.isText) {
+      if (node.marks && node.marks.length > 0) {
+        for (const mark of node.marks) {
+          if (mark.attrs?.uuid === uuid && mark.type.name === type) {
+            targetFound = true;
+            return true;
+          }
+        }
+      }
+
+      if (!targetFound) {
+        textOffset += node?.text?.length || 0;
+      }
+      return false;
+    }
+
+    // Handle nodes with content
+    if (node.content && node.content.size > 0) {
+      for (let i = 0; i < node.content.childCount; i++) {
+        const child = node.content.child(i);
+        const found = traverse(child);
+        if (found) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  };
+
+  if (parent.content && parent.content.size > 0) {
+    for (let i = 0; i < parent.content.childCount; i++) {
+      const child = parent.content.child(i);
+      const found = traverse(child);
+      if (found) break;
+    }
+  }
+
+  return targetFound ? textOffset : undefined;
+};
+
+export const nodeNotFound = (node: Node | Mark) => {
+  console.warn(
+    `Could not find position of node with uuid ${node.attrs.uuid} and type ${node.type.name}`,
+  );
+};