@eightyfourthousand/lib-editing 2026.4.0 → 2026.4.1

package/src/lib/transformers/recurse.ts

@@ -1,76 +0,0 @@
-import { AnnotationType } from '@eightyfourthousand/data-access';
-import { TransformationContextWithCallback, Transformer } from './transformer';
-import { TranslationEditorContentItem } from '../components';
-
-export const recurse: Transformer = (ctx) => {
-  if (trasformOnMatch(ctx)) {
-    return;
-  }
-
-  const { block } = ctx;
-  for (const child of block.content || []) {
-    if (trasformOnMatch({ ...ctx, parent: block, block: child })) {
-      return;
-    }
-
-    recurse({
-      ...ctx,
-      parent: block,
-      block: child,
-    });
-  }
-};
-
-const trasformOnMatch = (ctx: TransformationContextWithCallback) => {
-  const { block, annotation, until = [], transform } = ctx;
-  const type = block.type || 'unknown';
-  if (
-    block.attrs?.uuid !== annotation.uuid &&
-    block.attrs?.start <= annotation.start &&
-    block.attrs?.end >= annotation.end &&
-    (!until.length || until.includes(type as AnnotationType))
-  ) {
-    transform?.(ctx);
-    return true;
-  }
-
-  return false;
-};
-
-export const recurseForType = ({
-  block,
-  until,
-}: {
-  block: TranslationEditorContentItem;
-  until: AnnotationType;
-}): TranslationEditorContentItem | undefined => {
-  if (block.type === until) {
-    return block;
-  }
-
-  for (const child of block.content || []) {
-    const val = recurseForType({ block: child, until });
-    if (val) {
-      return val;
-    }
-  }
-};
-
-/**
- * Recursively searches a node tree to find the first text node that has marks applied.
- * Used in tests to verify that mark transformers (span, code, link, etc.) are working correctly.
- */
-export const findTextNodeWithMarks = (
-  node: TranslationEditorContentItem,
-): TranslationEditorContentItem | null => {
-  if (node.type === 'text' && node.marks && node.marks.length > 0) {
-    return node;
-  }
-  if (node.content) {
-    for (const child of node.content) {
-      const found = findTextNodeWithMarks(child);
-      if (found) return found;
-    }
-  }
-  return null;
-};

package/src/lib/transformers/reference.ts

@@ -1,3 +0,0 @@
-import { pass } from './transformer';
-
-export const reference = pass;

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

@@ -1,68 +0,0 @@
-import {
-  Annotation,
-  annotationsFromDTO,
-  PassageDTO,
-  passageFromDTO,
-} from '@eightyfourthousand/data-access';
-import { span } from './span';
-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: 'Some bold text here',
-  work_uuid: 'work-uuid-5678',
-  annotations: [
-    {
-      end: 14,
-      type: 'span',
-      uuid: 'span-uuid-1',
-      start: 5,
-      content: [
-        {
-          'text-style': 'text-bold',
-        },
-      ],
-      passage_uuid: 'passage-uuid-1234',
-    },
-  ],
-};
-
-describe('span 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 span annotation correctly', () => {
-    const annotation = passage.annotations.find(
-      (a: Annotation) => a.type === 'span',
-    ) as Annotation;
-    span({
-      root: block,
-      parent: block,
-      block,
-      annotation,
-    });
-
-    const textNode = findTextNodeWithMarks(block);
-    expect(textNode).toBeDefined();
-    expect(textNode?.type).toBe('text');
-    expect(textNode?.marks).toBeDefined();
-    const boldMark = textNode?.marks?.find((m: any) => m.type === 'bold');
-    expect(boldMark).toBeDefined();
-    expect(boldMark?.attrs?.uuid).toBe('span-uuid-1');
-    expect(boldMark?.attrs?.textStyle).toBe('text-bold');
-    expect(textNode?.text).toBe('bold text');
-  });
-});

package/src/lib/transformers/span.ts

@@ -1,78 +0,0 @@
-import { ExtendedTranslationLanguage, SpanAnnotation } from '@eightyfourthousand/data-access';
-import type { Transformer } from './transformer';
-import { type SpanMarkType, MARK_TYPES } from '../types';
-import { splitContent } from './split-content';
-import { ITALIC_LANGUAGES } from './annotate';
-import { recurse } from './recurse';
-
-const MARK_TYPE_FOR_SPAN_TYPE: {
-  [key: string]: (
-    lang?: ExtendedTranslationLanguage,
-  ) => SpanMarkType | undefined;
-} = {
-  distinct: () => 'italic',
-  emphasis: () => 'italic',
-  foreign: (lang) => {
-    if (lang && ITALIC_LANGUAGES.includes(lang)) {
-      return 'italic';
-    }
-    return undefined;
-  },
-  'small-caps': () => 'smallCaps',
-  subscript: () => 'subscript',
-  superscript: () => 'superscript',
-  'text-bold': () => 'bold',
-  underline: () => 'underline',
-};
-
-export const span: Transformer = (ctx) => {
-  const { annotation } = ctx;
-  const { textStyle, lang, uuid, start, end } = annotation as SpanAnnotation;
-  if (!textStyle) {
-    return;
-  }
-
-  const markType = MARK_TYPES.includes(textStyle)
-    ? textStyle
-    : MARK_TYPE_FOR_SPAN_TYPE[textStyle]?.(lang);
-  if (!markType) {
-    return;
-  }
-
-  recurse({
-    ...ctx,
-    until: ['text', 'glossaryInstance'],
-    transform: (ctx) => {
-      splitContent({
-        ...ctx,
-        transform: ({ block }) => {
-          // If the block already has the mark, skip it becuase the editor
-          // doesn't like multiple marks of the same type on a single block.
-          if (block.marks?.some((m) => m.type === markType)) {
-            return;
-          }
-
-          block.attrs = {
-            ...block.attrs,
-            start,
-            end,
-          };
-
-          block.marks = [
-            ...(block.marks || []),
-            {
-              type: markType,
-              attrs: {
-                ...block.attrs,
-                uuid,
-                type: 'span',
-                lang,
-                textStyle,
-              },
-            },
-          ];
-        },
-      });
-    },
-  });
-};

package/src/lib/transformers/split-at.ts

@@ -1,58 +0,0 @@
-import { Transformer } from './transformer';
-import { splitNode } from './split-node';
-import type { TranslationEditorContentItem } from '../components/editor';
-
-export const sort = (nodes: TranslationEditorContentItem[]) => {
-  return nodes.sort((a, b) => (a.attrs?.start ?? 0) - (b.attrs?.start ?? 0));
-};
-
-export const insert = (
-  node: TranslationEditorContentItem,
-  nodes: TranslationEditorContentItem[],
-) => {
-  // unshift to prioritize new block when sorting
-  nodes.unshift(node);
-  return sort(nodes);
-};
-
-export const splitContentAt: Transformer = (ctx) => {
-  const { root, parent, annotation, transform } = ctx;
-  const { start, end } = annotation;
-
-  if (start !== end) {
-    console.warn(
-      'splitContentAt: transformer expects to find an annotation with zero-length (insertion point).',
-    );
-    return;
-  }
-
-  if (!parent || !parent.content) {
-    console.warn(
-      'splitContentAt: transformer expects to find a parent block with content.',
-    );
-    return;
-  }
-
-  const annotationEnd = end;
-  const currentContent = parent.content || [];
-  const newContent = [];
-
-  for (const item of currentContent) {
-    const { prefix, middle, suffix } = splitNode(item, start, end);
-
-    const lastPrefix = prefix.at(-1);
-    const firstSuffix = suffix[0];
-
-    if (annotationEnd === lastPrefix?.attrs?.end) {
-      transform?.({ root, parent, block: lastPrefix, annotation });
-    } else if (annotationEnd === firstSuffix?.attrs?.end) {
-      transform?.({ root, parent, block: firstSuffix, annotation });
-    }
-
-    newContent.push(...prefix);
-    newContent.push(...middle);
-    newContent.push(...suffix);
-  }
-
-  parent.content = newContent;
-};

package/src/lib/transformers/split-block.ts

@@ -1,110 +0,0 @@
-import { AnnotationType } from '@eightyfourthousand/data-access';
-import { isBlockAnnotation } from './annotate';
-import { splitNode } from './split-node';
-import { Transformer } from './transformer';
-import { TranslationEditorContentItem } from '../components/editor';
-import { filterAttrs } from './util';
-
-export const splitBlock: Transformer = ({
-  root,
-  parent,
-  block,
-  annotation,
-  transform,
-}) => {
-  if (!isBlockAnnotation((block.type || 'unknown') as AnnotationType)) {
-    console.warn(
-      `splitBlock transformer expects to find a block annotation, but found: ${block?.type}`,
-    );
-    return;
-  }
-
-  if (!parent?.content?.length) {
-    console.warn(
-      'splitBlock transformer expects to find a parent block for the block.',
-    );
-    return;
-  }
-
-  const blockIndex = parent.content.findIndex(
-    (item) => item.attrs?.uuid === block.attrs?.uuid,
-  );
-
-  if (blockIndex === -1) {
-    console.warn(
-      'splitBlock transformer expects to find the block in its parent.',
-    );
-    return;
-  }
-
-  const annStart = annotation?.start ?? 0;
-  const annEnd = annotation?.end ?? 0;
-
-  if (annStart === annEnd) {
-    console.warn(
-      'splitBlock transformer expects to find an annotation with non-zero length.',
-    );
-    return;
-  }
-
-  const currentContent = block.content || [];
-  const prefixContent: typeof currentContent = [];
-  const midContent: typeof currentContent = [];
-  const suffixContent: typeof currentContent = [];
-
-  for (const item of currentContent) {
-    const { prefix, middle, suffix } = splitNode(item, annStart, annEnd);
-    prefixContent.push(...prefix);
-    midContent.push(...middle);
-    suffixContent.push(...suffix);
-  }
-
-  const attrs = filterAttrs(block.attrs);
-  const newBlocks: TranslationEditorContentItem[] = [];
-  if (prefixContent.length) {
-    newBlocks.push({
-      ...block,
-      content: prefixContent,
-      attrs: {
-        ...attrs,
-        start: prefixContent[0].attrs?.start ?? 0,
-        end: prefixContent[prefixContent.length - 1].attrs?.end ?? 0,
-      },
-    });
-  }
-
-  if (midContent.length) {
-    const newBlock: TranslationEditorContentItem = {
-      ...block,
-      type: annotation.type,
-      content: midContent,
-      attrs: {
-        ...attrs,
-        start: midContent[0].attrs?.start ?? annStart,
-        end: midContent[midContent.length - 1].attrs?.end ?? annEnd,
-        uuid: annotation.uuid,
-      },
-    };
-    transform?.({
-      root,
-      parent,
-      block: newBlock,
-      annotation,
-    });
-    newBlocks.push(newBlock);
-  }
-
-  if (suffixContent.length) {
-    newBlocks.push({
-      ...block,
-      content: suffixContent,
-      attrs: {
-        ...attrs,
-        start: suffixContent[0].attrs?.start ?? 0,
-        end: suffixContent[suffixContent.length - 1].attrs?.end ?? 0,
-      },
-    });
-  }
-
-  parent.content.splice(blockIndex, 1, ...newBlocks);
-};

package/src/lib/transformers/split-content.ts

@@ -1,67 +0,0 @@
-import { AnnotationType } from '@eightyfourthousand/data-access';
-import { isInlineAnnotation } from './annotate';
-import { Transformer } from './transformer';
-import { splitNode } from './split-node';
-import type { TranslationEditorContentItem } from '../components/editor';
-import { filterAttrs } from './util';
-
-export const splitContent: Transformer = ({
-  root,
-  parent,
-  block,
-  annotation,
-  transform,
-}) => {
-  if (!isInlineAnnotation(block.type as AnnotationType)) {
-    console.warn(
-      `splitContent: block type expects to find an inline annotation, but found: ${block.type}.`,
-    );
-    return;
-  }
-
-  if (!parent || !parent.content) {
-    console.warn(
-      'splitContent: transformer expects to find a parent block with content.',
-    );
-    return;
-  }
-
-  const annStartAbs = annotation.start;
-  const annEndAbs = annotation.end;
-  const currentContent = parent.content || [];
-  const newContent = [];
-  const attrs = filterAttrs(block.attrs);
-
-  for (const item of currentContent) {
-    const { prefix, middle, suffix } = splitNode(item, annStartAbs, annEndAbs);
-
-    newContent.push(...prefix);
-    // Only transform the middle segments
-    for (const midItem of middle) {
-      transform?.({
-        root,
-        parent,
-        block: midItem,
-        annotation,
-      });
-      newContent.push(midItem);
-    }
-    newContent.push(...suffix);
-  }
-
-  if (annStartAbs === annEndAbs && annStartAbs === attrs?.end) {
-    const newBlock: TranslationEditorContentItem = {
-      type: annotation.type,
-      attrs: {
-        ...attrs,
-        start: annStartAbs,
-        end: annEndAbs,
-      },
-    };
-    transform?.({ root, parent, block: newBlock, annotation });
-    newContent.push(newBlock);
-  }
-
-  newContent.sort((a, b) => (a.attrs?.start ?? 0) - (b.attrs?.start ?? 0));
-  parent.content = newContent;
-};

package/src/lib/transformers/split-insert.ts

@@ -1,76 +0,0 @@
-import { Transformer } from './transformer';
-import { splitNode } from './split-node';
-import type { TranslationEditorContentItem } from '../components/editor';
-import { filterAttrs } from './util';
-
-export const sort = (nodes: TranslationEditorContentItem[]) => {
-  return nodes.sort((a, b) => (a.attrs?.start ?? 0) - (b.attrs?.start ?? 0));
-};
-
-export const insert = (
-  node: TranslationEditorContentItem,
-  nodes: TranslationEditorContentItem[],
-) => {
-  // unshift to prioritize new block when sorting
-  nodes.unshift(node);
-  return sort(nodes);
-};
-
-export const splitAndInsert: Transformer = (ctx) => {
-  const { root, parent, block, annotation, transform } = ctx;
-  const { start, end } = annotation;
-
-  if (start !== end) {
-    console.warn(
-      'splitAndInsert: transformer expects to find an annotation with zero-length (insertion point).',
-    );
-    return;
-  }
-
-  if (!parent || !parent.content) {
-    console.warn(
-      'splitAndInsert: transformer expects to find a parent block with content.',
-    );
-    return;
-  }
-
-  const newBlock: TranslationEditorContentItem = {
-    type: annotation.type,
-    attrs: {
-      ...filterAttrs(block.attrs),
-      start,
-      end,
-    },
-  };
-  transform?.({ root, parent, block: newBlock, annotation });
-
-  if (start <= block.attrs?.start || start >= block.attrs?.end) {
-    parent.content = insert(newBlock, parent.content || []);
-    return;
-  }
-
-  const currentContent = parent.content || [];
-  const newContent = [];
-
-  let wasInserted = false;
-  for (const item of currentContent) {
-    const { prefix, middle, suffix } = splitNode(item, start, end);
-
-    newContent.push(...prefix);
-    for (const midItem of middle) {
-      newContent.push(midItem);
-      if (!wasInserted && midItem.attrs?.end === start) {
-        newContent.push(newBlock);
-        wasInserted = true;
-      }
-    }
-
-    if (!wasInserted) {
-      newContent.push(newBlock);
-      wasInserted = true;
-    }
-    newContent.push(...suffix);
-  }
-
-  parent.content = sort(newContent);
-};

package/src/lib/transformers/split-marks.ts

@@ -1,42 +0,0 @@
-export type TranslationMark = {
-  type: string;
-  attrs?: {
-    start?: number;
-    end?: number;
-    [key: string]: unknown;
-  };
-};
-
-export const splitMarks = ({
-  marks,
-  start,
-  end,
-}: {
-  marks?: TranslationMark[];
-  start: number;
-  end: number;
-}) => {
-  if (!marks) {
-    return;
-  }
-
-  const nextMarks = marks
-    .filter(
-      (mark) =>
-        (mark.attrs?.end ?? 0) <= end && (mark.attrs?.start ?? 0) <= end,
-    )
-    .map((mark) => {
-      const markStart = Math.max(mark.attrs?.start ?? 0, start);
-      const markEnd = Math.min(mark.attrs?.end ?? 0, end);
-      return {
-        ...mark,
-        attrs: {
-          ...mark.attrs,
-          start: markStart,
-          end: markEnd,
-        },
-      };
-    });
-
-  return nextMarks;
-};