@eightyfourthousand/lib-editing 2026.3.0

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

@@ -0,0 +1,58 @@
+import type { Node } from '@tiptap/pm/model';
+import { indent } from './indent';
+
+describe('indent exporter', () => {
+  it('should export indent annotation correctly', () => {
+    const node = {
+      attrs: {
+        indentUuid: 'indent-uuid-1234',
+      },
+      textContent: 'Indented text',
+    } as unknown as Node;
+
+    const result = indent({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'indent-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'indent',
+      start: 0,
+      end: 13,
+    });
+  });
+
+  it('should use parent textContent when node textContent is missing', () => {
+    const parent = {
+      textContent: 'Parent text',
+    } as unknown as Node;
+
+    const node = {
+      attrs: {
+        indentUuid: 'indent-uuid-5678',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = indent({
+      node,
+      parent,
+      root: parent,
+      start: 5,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'indent-uuid-5678',
+      passageUuid: 'passage-uuid-1234',
+      type: 'indent',
+      start: 5,
+      end: 16,
+    });
+  });
+});

package/src/lib/exporters/indent.ts

@@ -0,0 +1,18 @@
+import { IndentAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const indent: Exporter<IndentAnnotation> = ({
+  node,
+  parent,
+  start,
+  passageUuid,
+}): IndentAnnotation => {
+  const textContent = node.textContent || parent.textContent || '';
+  return {
+    uuid: node.attrs.indentUuid,
+    type: 'indent',
+    passageUuid,
+    start,
+    end: start + textContent.length,
+  };
+};

package/src/lib/exporters/index.ts

@@ -0,0 +1 @@
+export * from './annotation';

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

@@ -0,0 +1,90 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { internalLink } from './internal-link';
+
+describe('internalLink exporter', () => {
+  it('should export internalLink annotation correctly', () => {
+    const node = {
+      textContent: 'internal link',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'internal-link-uuid-1234',
+        type: 'passage',
+        entity: 'entity-uuid-5678',
+        href: '/passage/entity-uuid-5678',
+        isPending: false,
+      },
+    } as unknown as Mark;
+
+    const result = internalLink({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'internal-link-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'internalLink',
+      linkType: 'passage',
+      entity: 'entity-uuid-5678',
+      href: '/passage/entity-uuid-5678',
+      isPending: false,
+      start: 0,
+      end: 13,
+    });
+  });
+
+  it('should return undefined when textContent is missing', () => {
+    const node = {
+      textContent: '',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'internal-link-uuid-empty',
+        type: 'passage',
+        entity: 'entity-uuid-5678',
+      },
+    } as unknown as Mark;
+
+    const result = internalLink({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when entity is missing', () => {
+    const node = {
+      textContent: 'internal link',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'internal-link-uuid-noentity',
+        type: 'passage',
+      },
+    } as unknown as Mark;
+
+    const result = internalLink({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,35 @@
+import { InternalLinkAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const internalLink: Exporter<InternalLinkAnnotation> = ({
+  mark,
+  node,
+  start,
+  passageUuid,
+}): InternalLinkAnnotation | undefined => {
+  const textContent = node.textContent;
+  const linkType = mark?.attrs.type;
+  const entity = mark?.attrs.entity;
+  const uuid = mark?.attrs.uuid;
+  const href = mark?.attrs.href;
+  const isPending = mark?.attrs.isPending;
+
+  if (!textContent || !entity || !linkType || !uuid) {
+    console.warn(
+      `Internal link ${uuid} on pasage ${passageUuid} is incomplete`,
+    );
+    return undefined;
+  }
+
+  return {
+    uuid,
+    type: 'internalLink',
+    passageUuid,
+    linkType,
+    entity,
+    href,
+    isPending,
+    start,
+    end: start + textContent.length,
+  };
+};

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

@@ -0,0 +1,84 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { italic } from './italic';
+
+describe('italic exporter', () => {
+  it('should export inlineTitle annotation correctly', () => {
+    const node = {
+      textContent: 'Inline Title',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'italic-uuid-1234',
+        type: 'inlineTitle',
+        lang: 'en',
+      },
+    } as unknown as Mark;
+
+    const result = italic({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'italic-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'inlineTitle',
+      start: 0,
+      end: 12,
+      lang: 'en',
+    });
+  });
+
+  it('should export span annotation with emphasis by default', () => {
+    const node = {
+      textContent: 'emphasized text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'italic-uuid-5678',
+        type: 'span',
+      },
+    } as unknown as Mark;
+
+    const result = italic({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 5,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'italic-uuid-5678',
+      passageUuid: 'passage-uuid-1234',
+      type: 'span',
+      start: 5,
+      end: 20,
+      textStyle: 'emphasis',
+    });
+  });
+
+  it('should return undefined when mark is missing', () => {
+    const node = {
+      textContent: 'text',
+    } as unknown as Node;
+
+    const result = italic({
+      node,
+      mark: undefined,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/exporters/italic.ts

@@ -0,0 +1,55 @@
+import { Exporter, ExporterContext } from './export';
+import {
+  AnnotationType,
+  ExtendedTranslationLanguage,
+  InlineTitleAnnotation,
+  MantraAnnotation,
+  SpanAnnotation,
+} from '@eightyfourthousand/data-access';
+
+export const italic: Exporter<
+  InlineTitleAnnotation | MantraAnnotation | SpanAnnotation
+> = ({
+  mark,
+  node,
+  parent,
+  start,
+  passageUuid,
+}: ExporterContext):
+  | InlineTitleAnnotation
+  | MantraAnnotation
+  | SpanAnnotation
+  | undefined => {
+  if (!mark) {
+    console.warn('Italic exporter called without mark');
+    return undefined;
+  }
+
+  const uuid = mark?.attrs.uuid;
+  const type = mark?.attrs.type as AnnotationType;
+  const textContent = node.textContent || parent.textContent || '';
+  const textStyle = (mark?.attrs.textStyle as string) || 'emphasis';
+  const lang = mark?.attrs.lang as ExtendedTranslationLanguage;
+  const end = start + textContent.length;
+
+  switch (type) {
+    case 'inlineTitle':
+      return {
+        uuid,
+        type: 'inlineTitle',
+        passageUuid,
+        start,
+        end,
+        lang,
+      } as InlineTitleAnnotation;
+    default:
+      return {
+        uuid,
+        type: 'span',
+        passageUuid,
+        start,
+        end,
+        textStyle,
+      } as SpanAnnotation;
+  }
+};

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

@@ -0,0 +1,28 @@
+import type { Node } from '@tiptap/pm/model';
+import { leadingSpace } from './leading-space';
+
+describe('leadingSpace exporter', () => {
+  it('should export leadingSpace annotation correctly', () => {
+    const node = {
+      attrs: {
+        leadingSpaceUuid: 'leading-space-uuid-1234',
+      },
+    } as unknown as Node;
+
+    const result = leadingSpace({
+      node,
+      parent: node,
+      root: node,
+      start: 10,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'leading-space-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'leadingSpace',
+      start: 10,
+      end: 10,
+    });
+  });
+});

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

@@ -0,0 +1,16 @@
+import { LeadingSpaceAnnotation } from '@eightyfourthousand/data-access';
+import { Exporter } from './export';
+
+export const leadingSpace: Exporter<LeadingSpaceAnnotation> = ({
+  node,
+  start,
+  passageUuid,
+}): LeadingSpaceAnnotation => {
+  return {
+    uuid: node.attrs.leadingSpaceUuid,
+    type: 'leadingSpace',
+    passageUuid,
+    start,
+    end: start,
+  };
+};

package/src/lib/exporters/line-group.spec.ts

@@ -0,0 +1,48 @@
+import type { Node } from '@tiptap/pm/model';
+import { lineGroup } from './line-group';
+
+describe('lineGroup exporter', () => {
+  it('should export lineGroup annotation correctly', () => {
+    const node = {
+      attrs: {
+        uuid: 'linegroup-uuid-1234',
+      },
+      textContent: 'First line\nSecond line\nThird line',
+    } as unknown as Node;
+
+    const result = lineGroup({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'linegroup-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'lineGroup',
+      start: 0,
+      end: 33,
+    });
+  });
+
+  it('should return undefined when textContent is empty', () => {
+    const node = {
+      attrs: {
+        uuid: 'linegroup-uuid-empty',
+      },
+      textContent: '',
+    } as unknown as Node;
+
+    const result = lineGroup({
+      node,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});

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

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

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

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

package/src/lib/exporters/line.ts

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

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

@@ -0,0 +1,123 @@
+import type { Node, Mark } from '@tiptap/pm/model';
+import { link } from './link';
+
+describe('link exporter', () => {
+  it('should export link annotation correctly', () => {
+    const node = {
+      textContent: 'link text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'link-uuid-1234',
+        type: 'link',
+        href: 'https://example.com',
+        text: 'Example Link',
+      },
+      type: { name: 'link' },
+    } as unknown as Mark;
+
+    const result = link({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'link-uuid-1234',
+      passageUuid: 'passage-uuid-1234',
+      type: 'link',
+      start: 0,
+      end: 9,
+      href: 'https://example.com',
+      text: 'Example Link',
+    });
+  });
+
+  it('should export reference annotation correctly', () => {
+    const node = {
+      textContent: 'reference text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'ref-uuid-5678',
+        type: 'reference',
+        href: '/passage/123',
+      },
+      type: { name: 'reference' },
+    } as unknown as Mark;
+
+    const result = link({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 5,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toEqual({
+      uuid: 'ref-uuid-5678',
+      passageUuid: 'passage-uuid-1234',
+      type: 'reference',
+      start: 5,
+      end: 19,
+      href: '/passage/123',
+    });
+  });
+
+  it('should return undefined when href is missing', () => {
+    const node = {
+      textContent: 'link text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'link-uuid-nohref',
+        type: 'link',
+      },
+      type: { name: 'link' },
+    } as unknown as Mark;
+
+    const result = link({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when type is invalid', () => {
+    const node = {
+      textContent: 'link text',
+    } as unknown as Node;
+
+    const mark = {
+      attrs: {
+        uuid: 'link-uuid-invalid',
+        type: 'invalidType',
+        href: 'https://example.com',
+      },
+      type: { name: 'invalidType' },
+    } as unknown as Mark;
+
+    const result = link({
+      node,
+      mark,
+      parent: node,
+      root: node,
+      start: 0,
+      passageUuid: 'passage-uuid-1234',
+    });
+
+    expect(result).toBeUndefined();
+  });
+});