@eightyfourthousand/lib-editing 2026.4.0 → 2026.4.2

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

@@ -1,48 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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}`,
-  );
-};

package/src/lib/passage.ts

@@ -1,182 +0,0 @@
-import { Editor } from '@tiptap/react';
-import { Node } from '@tiptap/pm/model';
-import { v4 as uuidv4 } from 'uuid';
-import {
-  annotationExportsFromNode,
-  markAnnotationFromNode,
-  parameterAnnotationFromNode,
-} from './exporters';
-import { findNodePosition, nodeNotFound } from './exporters/util';
-import { ExporterContext } from './exporters/export';
-import { Passage } from '@eightyfourthousand/data-access';
-
-/**
- * Ensures every node in the editor document has a unique, non-null UUID.
- *
- * UUID assignment normally happens asynchronously in NodeView lifecycle hooks
- * (validateAttrs / createNodeViewDom). When save() is called shortly after a
- * structural edit (e.g. pressing Enter to create a new paragraph, or splitting
- * a passage), some nodes may still carry uuid: null or a UUID duplicated from
- * the node they were split from.  passagesFromNodes() then reads those nodes
- * synchronously, and annotationExportsFromNode silently skips any node whose
- * uuid is falsy — producing missing paragraph annotations.
- *
- * This function walks the document synchronously and dispatches a single
- * transaction that stamps a fresh UUID onto every node or mark that either:
- *   1. has uuid: null / undefined / empty, OR
- *   2. duplicates the UUID of another node/mark already seen in this walk.
- *
- * Block nodes are updated via tr.setNodeMarkup. Inline marks (Link,
- * InternalLink, GlossaryInstance) carry their own uuid attribute and are
- * updated via tr.removeMark + tr.addMark, since setNodeMarkup does not apply
- * to marks. This prevents duplicate annotation UUIDs when a passage is split
- * and the afterContent inherits copies of the original marks.
- *
- * It must be called (and awaited via a Promise.resolve()) before
- * passagesFromNodes() so that the transaction is committed to the editor state.
- */
-// Parameter annotation UUID attributes that live on block node attrs (not marks)
-// and must be deduplicated alongside the main `uuid` attribute.
-const PARAMETER_UUID_ATTRS = ['leadingSpaceUuid', 'indentUuid'] as const;
-
-export const ensureUuids = (editor: Editor): void => {
-  const { state, view } = editor;
-  const { doc, tr } = state;
-  const seen = new Set<string>();
-  let changed = false;
-
-  doc.descendants((node, pos) => {
-    // text and doc nodes never carry a uuid
-    if (node.type.name === 'text' || node.type.name === 'doc') {
-      return true;
-    }
-
-    let newAttrs: Record<string, unknown> | null = null;
-
-    // Check main uuid
-    const existing: string | null | undefined = node.attrs.uuid;
-    if (!existing || seen.has(existing)) {
-      newAttrs = { ...node.attrs, uuid: uuidv4() };
-      seen.add(newAttrs.uuid as string);
-    } else {
-      seen.add(existing);
-    }
-
-    // Check parameter annotation UUIDs
-    for (const attrKey of PARAMETER_UUID_ATTRS) {
-      const existingParam = node.attrs[attrKey] as string | null | undefined;
-      if (existingParam === undefined) continue; // node type doesn't use this attr
-      if (!existingParam || seen.has(existingParam)) {
-        newAttrs = { ...(newAttrs ?? node.attrs), [attrKey]: uuidv4() };
-        seen.add(newAttrs[attrKey] as string);
-      } else {
-        seen.add(existingParam);
-      }
-    }
-
-    if (newAttrs) {
-      tr.setNodeMarkup(pos, undefined, newAttrs);
-      changed = true;
-    }
-
-    return true;
-  });
-
-  // Second pass: walk text nodes and fix marks that carry a uuid attribute
-  // (Link, InternalLink, GlossaryInstance). doc.descendants does not expose
-  // marks directly, so we must walk text nodes to find them.
-  doc.descendants((node, pos) => {
-    if (node.type.name !== 'text' || node.marks.length === 0) return true;
-
-    for (const mark of node.marks) {
-      const existing: string | null | undefined = mark.attrs.uuid;
-      if (existing === undefined) continue; // mark type has no uuid attribute
-
-      const isDuplicate = existing ? seen.has(existing) : false;
-      if (!existing || isDuplicate) {
-        const newUuid = uuidv4();
-        const newMark = mark.type.create({ ...mark.attrs, uuid: newUuid });
-        // pos is the start of the text node; the mark spans the full text node
-        tr.removeMark(pos, pos + node.nodeSize, mark.type);
-        tr.addMark(pos, pos + node.nodeSize, newMark);
-        seen.add(newUuid);
-        changed = true;
-      } else {
-        seen.add(existing);
-      }
-    }
-
-    return true;
-  });
-
-  if (changed) {
-    view.dispatch(tr);
-  }
-};
-
-export const passageFromNode = (node: Node, workUuid: string): Passage => {
-  const uuid = node.attrs.uuid;
-  const type = node.attrs.type;
-  const toh = node.attrs.toh;
-
-  const ctx: ExporterContext = {
-    passageUuid: uuid,
-    node,
-    parent: node,
-    root: node,
-    start: 0,
-  };
-  const annotations = [
-    ...parameterAnnotationFromNode(ctx),
-    ...markAnnotationFromNode(ctx),
-  ];
-  node.content.forEach((child) => {
-    const start = findNodePosition(node, child.attrs.uuid, child.type.name);
-    if (start === undefined) {
-      return nodeNotFound(child);
-    }
-    annotations.push(
-      ...annotationExportsFromNode({
-        passageUuid: uuid,
-        node: child,
-        parent: node,
-        root: node,
-        start,
-      }),
-    );
-  });
-
-  const passage: Passage = {
-    uuid,
-    type,
-    workUuid,
-    sort: node.attrs.sort,
-    label: node.attrs.label,
-    content: node.textContent,
-    toh,
-    annotations,
-  };
-  return passage;
-};
-
-export const passagesFromNodes = ({
-  uuids,
-  workUuid,
-  editor,
-}: {
-  uuids: string[];
-  workUuid: string;
-  editor: Editor;
-}): Passage[] => {
-  const passages: Passage[] = [];
-  uuids.forEach((uuid) => {
-    const node = editor.$node('passage', { uuid });
-    if (!node) {
-      console.warn(`No passage node found for uuid: ${uuid}`);
-      return;
-    }
-
-    passages.push(passageFromNode(node.node, workUuid));
-  });
-  return passages;
-};

package/src/lib/titles.ts

@@ -1,80 +0,0 @@
-import {
-  type ExtendedTranslationLanguage,
-  TITLE_TYPES,
-  type Titles,
-  type TitleType,
-} from '@eightyfourthousand/data-access';
-import type { BlockEditorContent } from './components';
-
-const TYPE_FOR_LANGUAGE: Record<ExtendedTranslationLanguage | 'toh', string> = {
-  toh: 'tohTitle',
-  bo: 'boTitle',
-  en: 'enTitle',
-  ja: 'jaTitle',
-  zh: 'zhTitle',
-  'Bo-Ltn': 'boLtnTitle',
-  'Mt-Ltn': 'mtLtnTitle',
-  'Pi-Ltn': 'piLtnTitle',
-  'Sa-Ltn': 'saLtnTitle',
-  'Zh-Ltn': 'zhLtnTitle',
-};
-
-const TITLES_TYPE_TO_NODE_TYPE: Record<TitleType, string> = {
-  toh: 'tohs',
-  mainTitle: 'mainTitles',
-  mainTitleOutsideCatalogueSection: 'alternateMainTitles',
-  longTitle: 'longTitles',
-  otherTitle: 'otherTitles',
-  shortcode: 'shortCodes',
-};
-
-export const titlesToDocument = (titles: Titles): BlockEditorContent => {
-  const content: BlockEditorContent = {
-    type: 'titles',
-    content: [],
-  };
-
-  const titlesByType: Partial<Record<TitleType, Titles>> = {};
-  titles.forEach((title) => {
-    if (!titlesByType[title.type]) {
-      titlesByType[title.type] = [];
-    }
-    titlesByType[title.type]?.push(title);
-  });
-
-  // NOTE: the imported list is already in preferred order
-  TITLE_TYPES.forEach((type) => {
-    const titlesOfType = titlesByType[type];
-    if (titlesOfType?.length) {
-      const orderedTitles = [
-        ...titlesOfType.filter((title) => title.language === 'bo'),
-        ...titlesOfType.filter((title) => title.language === 'en'),
-        ...titlesOfType.filter((title) => title.language === 'Bo-Ltn'),
-        ...titlesOfType.filter((title) => title.language === 'Sa-Ltn'),
-        ...titlesOfType.filter((title) => title.language === 'Pi-Ltn'),
-        ...titlesOfType.filter((title) => title.language === 'zh'),
-        ...titlesOfType.filter((title) => title.language === 'ja'),
-      ];
-
-      content.content?.push({
-        type: TITLES_TYPE_TO_NODE_TYPE[type],
-        content: orderedTitles.map((title) => ({
-          type: TYPE_FOR_LANGUAGE[title.language],
-          attrs: {
-            language: title.language,
-            uuid: title.uuid,
-            type: title.type,
-          },
-          content: [
-            {
-              type: 'text',
-              text: title.title,
-            },
-          ],
-        })),
-      });
-    }
-  });
-
-  return content;
-};

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

@@ -1,87 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { abbreviation } from './abbreviation';
-import { blockFromPassage } from '../block';
-import { recurseForType } from './recurse';
-
-const dto: PassageDTO = {
-  sort: 13140,
-  type: 'abbreviations',
-  uuid: 'e350ec6c-a40c-46bf-8182-acba5a50e4fe',
-  label: '',
-  xmlId: 'UT22084-001-001-2226',
-  parent: 'UT22084-001-001-notes-1',
-  content: 'C Choné',
-  work_uuid: '092e9a3c-12a6-4e1c-a05b-16835c0e62a8',
-  annotations: [
-    {
-      end: 2,
-      type: 'abbreviation',
-      uuid: '49c41c6d-0e04-412e-81ad-22f3af377470',
-      start: 0,
-      content: [
-        {
-          uuid: 'e350ec6c-a40c-46bf-8182-acba5a50e4fe',
-        },
-      ],
-      passage_uuid: 'e350ec6c-a40c-46bf-8182-acba5a50e4fe',
-    },
-    {
-      end: 7,
-      type: 'has-abbreviation',
-      uuid: '1e5003e8-e015-4b94-b88c-80b39c263098',
-      start: 2,
-      content: [
-        {
-          uuid: 'e350ec6c-a40c-46bf-8182-acba5a50e4fe',
-        },
-      ],
-      passage_uuid: 'e350ec6c-a40c-46bf-8182-acba5a50e4fe',
-    },
-  ],
-};
-
-describe('abbreviation transformer', () => {
-  const passage = passageFromDTO(
-    dto,
-    annotationsFromDTO(dto.annotations || []),
-  );
-  const block = blockFromPassage(passage);
-
-  if (!block?.content) {
-    throw new Error('Block conversion failed');
-  }
-
-  it('should transform abbreviation annotation correctly', () => {
-    const annotation = passage.annotations.find(
-      (a: Annotation) => a.type === 'abbreviation',
-    ) as Annotation;
-    abbreviation({
-      root: block,
-      parent: block,
-      block,
-      annotation,
-    });
-
-    const val = recurseForType({
-      until: 'abbreviation',
-      block,
-    });
-
-    expect(val).toBeDefined();
-    expect(val?.type).toBe('abbreviation');
-    expect(val?.attrs).toBeDefined();
-    expect(val?.attrs?.abbreviation).toBe(
-      'e350ec6c-a40c-46bf-8182-acba5a50e4fe',
-    );
-    expect(val?.attrs?.uuid).toBe('49c41c6d-0e04-412e-81ad-22f3af377470');
-    expect(val?.content).toBeDefined();
-    expect(val?.content?.length).toBe(1);
-    expect(val?.content?.[0].type).toBe('text');
-    expect(val?.content?.[0].text).toBe('C ');
-  });
-});

package/src/lib/transformers/abbreviation.ts

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