tycho-components 0.41.7 → 0.42.1

package/dist/configs/types/Struct.d.ts

@@ -11,8 +11,12 @@ export type Chunk = {
     f: number;
     l: number;
     t: string;
+    /** Stable chunk identity (4-char alphanumeric), mirrors token `tid`. */
+    kid?: string;
     coidx?: number[];
     ep?: boolean;
+    /** Runtime: empty-category phrase node. */
+    empty?: boolean;
 };
 export type Token = {
     p: number;

package/dist/features/PageRender/collapseElementsForTier.js

@@ -109,8 +109,9 @@ export function shouldSkipJunctionContinuationElement(elements, index, selectedT
         if (element.type === PageRenderElementType.JUNCTION_SPLIT &&
             splitIdx > 0 &&
             segmented) {
-            const lastP = getGlobalLastSegmentationPos(elements, ref.uid, segmentationGroup);
-            if (lastP !== null && ref.p < lastP) {
+            // Only hand later splits to a later host when that host also has junction
+            // (two-host diplomatic pattern). Seg-only follow-ons must not hide idx>0.
+            if (hasLaterJunctionHostInSegmentationGroup(elements, ref.uid, segmentationGroup, ref.p)) {
                 return true;
             }
         }
@@ -196,6 +197,30 @@ function getLastSegmentationPosInGroup(elements, start, end) {
     }
     return lastP;
 }
+function groupHasJunctionHost(elements, start, end) {
+    for (let i = start; i <= end; i += 1) {
+        const ref = elements[i].token;
+        if (ref && hasJunctionFromRef(ref)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasLaterJunctionHostInSegmentationGroup(elements, uid, groupKey, currentP) {
+    for (const element of elements) {
+        if (!isJunctionEditionElement(element))
+            continue;
+        const ref = element.token;
+        if (!sameSegmentationGroupRef(ref, uid, groupKey))
+            continue;
+        if (!hasSegmentationFromRef(ref))
+            continue;
+        if (ref.p > currentP) {
+            return true;
+        }
+    }
+    return false;
+}
 export function shouldSkipSegmentationElement(elements, index, selectedTier, corpus) {
     if (!isUnderSelected(selectedTier, SEGMENTATION_TIER, corpus)) {
         return false;
@@ -205,19 +230,99 @@ export function shouldSkipSegmentationElement(elements, index, selectedTier, cor
         return false;
     }
     const { start, end } = findSegmentationGroupBounds(elements, index);
+    const ref = element.token;
+    // Junction host + seg-only pieces: diplomatic text lives on the junction host.
+    if (groupHasJunctionHost(elements, start, end)) {
+        if (hasJunctionFromRef(ref)) {
+            return false;
+        }
+        return true;
+    }
     const lastP = getLastSegmentationPosInGroup(elements, start, end);
-    return element.token.p < lastP;
+    return ref.p < lastP;
 }
 /** @deprecated Use shouldSkipSegmentationElement */
 export function shouldSkipSegmentationToken(elements, index, selectedTier, corpus) {
     return shouldSkipSegmentationElement(elements, index, selectedTier, corpus);
 }
+function isMidJunctionHostLineBreak(elements, index) {
+    if (elements[index]?.type !== PageRenderElementType.LINE_BREAK) {
+        return false;
+    }
+    const prev = elements[index - 1];
+    if (prev?.type !== PageRenderElementType.JUNCTION_SPLIT || !prev.token) {
+        return false;
+    }
+    let nextIdx = index + 1;
+    while (nextIdx < elements.length &&
+        elements[nextIdx].type === PageRenderElementType.LINE_NUMBER) {
+        nextIdx += 1;
+    }
+    const next = elements[nextIdx];
+    if (next?.type !== PageRenderElementType.JUNCTION_SPLIT || !next.token) {
+        return false;
+    }
+    return prev.token.uid === next.token.uid && prev.token.p === next.token.p;
+}
+function sameDeferredBreakGroup(element, group) {
+    const ref = element.token;
+    if (!ref)
+        return false;
+    if (ref.uid === group.uid && ref.p === group.p)
+        return true;
+    if (group.segGroup &&
+        hasSegmentationFromRef(ref) &&
+        sameSegmentationGroupRef(ref, group.uid, group.segGroup)) {
+        return true;
+    }
+    return false;
+}
 export default function collapseElementsForTier(elements, selectedTier, corpus) {
     const showJunctionSplits = isUnderSelected(selectedTier, JUNCTION_TIER, corpus);
     const collapsed = [];
     let index = 0;
+    let deferredBreak = null;
+    let deferredLineNumbers = [];
+    let deferredBreakGroup = null;
+    const flushDeferredBreak = () => {
+        if (!deferredBreak)
+            return;
+        collapsed.push({
+            kind: 'single',
+            element: deferredBreak,
+            key: `LINE_BREAK_deferred_${collapsed.length}`,
+        });
+        for (const lineNumber of deferredLineNumbers) {
+            collapsed.push({
+                kind: 'single',
+                element: lineNumber,
+                key: `LINE_NUMBER_deferred_${collapsed.length}`,
+            });
+        }
+        deferredBreak = null;
+        deferredLineNumbers = [];
+        deferredBreakGroup = null;
+    };
     while (index < elements.length) {
         const element = elements[index];
+        if (!showJunctionSplits &&
+            deferredBreak === null &&
+            isMidJunctionHostLineBreak(elements, index)) {
+            const host = elements[index - 1].token;
+            deferredBreak = element;
+            deferredBreakGroup = {
+                uid: host.uid,
+                p: host.p,
+                segGroup: segmentationGroupKey(host),
+            };
+            index += 1;
+            while (index < elements.length &&
+                elements[index].type === PageRenderElementType.LINE_NUMBER) {
+                deferredLineNumbers.push(elements[index]);
+                index += 1;
+            }
+            continue;
+        }
         if (shouldSkipSegmentationElement(elements, index, selectedTier, corpus)) {
             index += 1;
             continue;
@@ -226,6 +331,12 @@ export default function collapseElementsForTier(elements, selectedTier, corpus)
             index += 1;
             continue;
         }
+        const inDeferredGroup = !!element.token &&
+            !!deferredBreakGroup &&
+            sameDeferredBreakGroup(element, deferredBreakGroup);
+        if (deferredBreak && !inDeferredGroup) {
+            flushDeferredBreak();
+        }
         if (!showJunctionSplits &&
             element.type === PageRenderElementType.JUNCTION_SPLIT &&
             element.token) {
@@ -251,6 +362,7 @@ export default function collapseElementsForTier(elements, selectedTier, corpus)
         });
         index += 1;
     }
+    flushDeferredBreak();
     return collapsed;
 }
 export function isTokenBearingCollapsed(item) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tycho-components",
   "private": false,
-  "version": "0.41.7",
+  "version": "0.42.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {