tycho-components 0.36.10 → 0.37.0

package/dist/configs/useMessageUtils.js

@@ -14,7 +14,7 @@ export const getErrorMessageValue = ({ err, t, key }) => {
         return translateErrorValue(t, key ?? "message", String(err));
     }
     if (err.response.status === 403) {
-        return t("error.access.authorization");
+        return t("error.access.authorization", { ns: "message" });
     }
     let errorKey = "";
     if (err.response.data?.message) {

package/dist/features/PageRender/PageRenderView.d.ts

@@ -0,0 +1,2 @@
+import { PageRenderViewProps } from './types';
+export default function PageRenderView({ elements, selectedTier, corpus, document, displayTags, showLineNumbers, highlightSentenceUid, getDisplayValue, getTokenStyle, isTokenEdited, getParticipantName, getParticipantColor, onTokenClick, }: PageRenderViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/PageRender/PageRenderView.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import cx from 'classnames';
+import collapseElementsForTier from './collapseElementsForTier';
+import isTokenRefVisible, { tokenRefToToken } from './tokenUtils';
+import { PageRenderElementType, } from './types';
+export default function PageRenderView({ elements, selectedTier, corpus, document, displayTags = false, showLineNumbers = true, highlightSentenceUid, getDisplayValue, getTokenStyle, isTokenEdited, getParticipantName, getParticipantColor, onTokenClick, }) {
+    const collapsed = collapseElementsForTier(elements, selectedTier, corpus);
+    return (_jsx("div", { className: "page-render-elements", children: collapsed.map((item) => (_jsx(PageRenderElementItem, { item: item, highlight: highlightSentenceUid != null &&
+                sentenceUidForItem(item) === highlightSentenceUid, showLineNumbers: showLineNumbers, displayTags: displayTags, getDisplayValue: getDisplayValue, getTokenStyle: getTokenStyle, isTokenEdited: isTokenEdited, getParticipantName: getParticipantName, getParticipantColor: getParticipantColor, onTokenClick: onTokenClick, document: document }, item.key))) }));
+}
+function sentenceUidForItem(item) {
+    if (item.kind === 'collapsedJunction')
+        return item.token.uid;
+    if (item.kind === 'single' && item.element.token)
+        return item.element.token.uid;
+    return undefined;
+}
+function PageRenderElementItem({ item, highlight, showLineNumbers, displayTags, document, getDisplayValue, getTokenStyle, isTokenEdited, getParticipantName, getParticipantColor, onTokenClick, }) {
+    if (item.kind === 'collapsedJunction') {
+        return renderToken(item.token, item.splitIdx ?? 0, true, highlight, displayTags, getDisplayValue, getTokenStyle, isTokenEdited, onTokenClick);
+    }
+    const { element } = item;
+    switch (element.type) {
+        case PageRenderElementType.PARTICIPANT:
+            if (!element.participant)
+                return null;
+            return (_jsx("span", { className: "participant", style: getParticipantColor
+                    ? { backgroundColor: getParticipantColor(element.participant) }
+                    : undefined, children: getParticipantName
+                    ? getParticipantName(element.participant)
+                    : element.participant }));
+        case PageRenderElementType.LINE_BREAK:
+            return _jsx("hr", { className: "line-break" });
+        case PageRenderElementType.LINE_NUMBER:
+            if (!showLineNumbers || element.line == null)
+                return null;
+            return _jsx("span", { className: "line-break-number", children: element.line });
+        case PageRenderElementType.MARK:
+            if (!element.token)
+                return null;
+            return renderToken(element.token, 0, false, highlight, displayTags, getDisplayValue, getTokenStyle, isTokenEdited, onTokenClick, true);
+        case PageRenderElementType.JUNCTION_SPLIT:
+            if (!element.token)
+                return null;
+            return renderToken(element.token, element.idx ?? 0, true, highlight, displayTags, getDisplayValue, getTokenStyle, isTokenEdited, onTokenClick);
+        case PageRenderElementType.TOKEN:
+            if (!element.token)
+                return null;
+            return renderToken(element.token, 0, false, highlight, displayTags, getDisplayValue, getTokenStyle, isTokenEdited, onTokenClick);
+        default:
+            return null;
+    }
+}
+function renderToken(ref, splitIdx, isSplit, highlight, displayTags, getDisplayValue, getTokenStyle, isTokenEdited, onTokenClick, isMark = false) {
+    const token = tokenRefToToken(ref);
+    const displaySplits = token.ec && token.split && !displayTags;
+    const visible = isMark || isTokenRefVisible(ref);
+    const tokenClass = cx('token', {
+        split: isSplit,
+        'd-none': !visible || !!displaySplits,
+        edited: isTokenEdited ? isTokenEdited(token) : !!ref.edited,
+        highlight,
+        mark: isMark,
+    });
+    const anchorId = highlight && ref.p === 1 ? 'selected' : undefined;
+    return (_jsxs("div", { id: anchorId, className: tokenClass, style: getTokenStyle?.(token), onClick: onTokenClick ? () => onTokenClick(ref, splitIdx) : undefined, children: [getDisplayValue(token, splitIdx), displayTags && (_jsxs("b", { className: "tag", children: ["/", token.split ? token.split.t : token.t] }))] }));
+}

package/dist/features/PageRender/collapseElementsForTier.d.ts

@@ -0,0 +1,12 @@
+import { CollapsedPageRenderElement, PageRenderElement } from './types';
+import type { Corpus } from '../../configs/types/Corpus';
+export declare function shouldSkipJunctionContinuationElement(elements: PageRenderElement[], index: number, selectedTier: string, corpus?: Corpus | null): boolean;
+export declare function findSegmentationGroupBounds(elements: PageRenderElement[], index: number): {
+    start: number;
+    end: number;
+};
+export declare function shouldSkipSegmentationElement(elements: PageRenderElement[], index: number, selectedTier: string, corpus?: Corpus | null): boolean;
+/** @deprecated Use shouldSkipSegmentationElement */
+export declare function shouldSkipSegmentationToken(elements: PageRenderElement[], index: number, selectedTier: string, corpus?: Corpus | null): boolean;
+export default function collapseElementsForTier(elements: PageRenderElement[], selectedTier: string, corpus?: Corpus | null): CollapsedPageRenderElement[];
+export declare function isTokenBearingCollapsed(item: CollapsedPageRenderElement): boolean;

package/dist/features/PageRender/collapseElementsForTier.js

@@ -0,0 +1,262 @@
+import { isUnderSelected, JUNCTION_TIER, SEGMENTATION_TIER, } from './editionTierOrder';
+import { PageRenderElementType, } from './types';
+function sameJunctionGroup(a, b) {
+    if (a.type !== PageRenderElementType.JUNCTION_SPLIT ||
+        b.type !== PageRenderElementType.JUNCTION_SPLIT ||
+        !a.token ||
+        !b.token) {
+        return false;
+    }
+    return a.token.uid === b.token.uid && a.token.p === b.token.p;
+}
+function hasJunctionFromRef(ref) {
+    const ops = ref.edition?.ops;
+    return ops !== undefined && ops[JUNCTION_TIER] !== undefined;
+}
+function hasSegmentationFromRef(ref) {
+    const ops = ref.edition?.ops;
+    return ops !== undefined && ops[SEGMENTATION_TIER] !== undefined;
+}
+function segmentationGroupKey(ref) {
+    return ref.edition?.sg || ref.edition?.id;
+}
+function sameSegmentationGroupRef(ref, uid, groupKey) {
+    return ref.uid === uid && segmentationGroupKey(ref) === groupKey;
+}
+function isJunctionEditionElement(element) {
+    if (!element.token)
+        return false;
+    if (element.type !== PageRenderElementType.TOKEN &&
+        element.type !== PageRenderElementType.JUNCTION_SPLIT) {
+        return false;
+    }
+    return hasJunctionFromRef(element.token);
+}
+function getGlobalFirstJunctionPos(elements, uid, editionId) {
+    let firstP = null;
+    for (const element of elements) {
+        if (!isJunctionEditionElement(element))
+            continue;
+        const ref = element.token;
+        if (ref.uid !== uid || ref.edition?.id !== editionId)
+            continue;
+        if (firstP === null || ref.p < firstP) {
+            firstP = ref.p;
+        }
+    }
+    return firstP;
+}
+function getGlobalLastJunctionPos(elements, uid, editionId) {
+    let lastP = null;
+    for (const element of elements) {
+        if (!isJunctionEditionElement(element))
+            continue;
+        const ref = element.token;
+        if (ref.uid !== uid || ref.edition?.id !== editionId)
+            continue;
+        if (lastP === null || ref.p > lastP) {
+            lastP = ref.p;
+        }
+    }
+    return lastP;
+}
+function getGlobalLastSegmentationPos(elements, uid, groupKey) {
+    let lastP = null;
+    for (const element of elements) {
+        if (!isSegmentationEditionElement(element))
+            continue;
+        const ref = element.token;
+        if (!sameSegmentationGroupRef(ref, uid, groupKey))
+            continue;
+        if (lastP === null || ref.p > lastP) {
+            lastP = ref.p;
+        }
+    }
+    return lastP;
+}
+function hasVisibleEarlierJunctionHost(elements, index, selectedTier, corpus) {
+    const ref = elements[index].token;
+    const editionId = ref.edition?.id;
+    for (let i = 0; i < index; i += 1) {
+        const earlier = elements[i];
+        if (!isJunctionEditionElement(earlier))
+            continue;
+        const earlierRef = earlier.token;
+        if (earlierRef.uid !== ref.uid || earlierRef.edition?.id !== editionId) {
+            continue;
+        }
+        if (earlierRef.p >= ref.p)
+            continue;
+        if (shouldSkipSegmentationElement(elements, i, selectedTier, corpus))
+            continue;
+        if ((earlier.idx ?? 0) === 0)
+            return true;
+    }
+    return false;
+}
+export function shouldSkipJunctionContinuationElement(elements, index, selectedTier, corpus) {
+    const element = elements[index];
+    if (!isJunctionEditionElement(element)) {
+        return false;
+    }
+    const ref = element.token;
+    const splitIdx = element.idx ?? 0;
+    const editionId = ref.edition?.id;
+    const segmentationGroup = segmentationGroupKey(ref);
+    const segmented = hasSegmentationFromRef(ref);
+    // Original layer: separated junction parts; dedupe hosts/suffixes when segmented
+    if (isUnderSelected(selectedTier, JUNCTION_TIER, corpus)) {
+        if (element.type === PageRenderElementType.JUNCTION_SPLIT &&
+            splitIdx > 0 &&
+            segmented) {
+            const lastP = getGlobalLastSegmentationPos(elements, ref.uid, segmentationGroup);
+            if (lastP !== null && ref.p < lastP) {
+                return true;
+            }
+        }
+        if (splitIdx === 0 &&
+            segmented &&
+            hasVisibleEarlierJunctionHost(elements, index, selectedTier, corpus)) {
+            return true;
+        }
+        return false;
+    }
+    // Junction tier or higher: one surface per struct token (idx 0 only; collapse merges splits)
+    if (element.type === PageRenderElementType.JUNCTION_SPLIT && splitIdx > 0) {
+        return true;
+    }
+    const lastP = segmented
+        ? getGlobalLastSegmentationPos(elements, ref.uid, segmentationGroup) ??
+            getGlobalLastJunctionPos(elements, ref.uid, editionId)
+        : getGlobalLastJunctionPos(elements, ref.uid, editionId);
+    if (lastP === null) {
+        return false;
+    }
+    if (segmented &&
+        hasDistinctSegmentationOpsAcrossHosts(elements, ref.uid, segmentationGroup)) {
+        return false;
+    }
+    return ref.p !== lastP;
+}
+function isSegmentationEditionElement(element) {
+    if (!element.token)
+        return false;
+    if (element.type !== PageRenderElementType.TOKEN &&
+        element.type !== PageRenderElementType.JUNCTION_SPLIT) {
+        return false;
+    }
+    return hasSegmentationFromRef(element.token);
+}
+function hasDistinctSegmentationOpsAcrossHosts(elements, uid, groupKey) {
+    const segValues = new Set();
+    for (const element of elements) {
+        if (!isSegmentationEditionElement(element))
+            continue;
+        const ref = element.token;
+        if (!sameSegmentationGroupRef(ref, uid, groupKey))
+            continue;
+        const seg = ref.edition?.ops?.seg;
+        if (seg !== undefined)
+            segValues.add(seg);
+    }
+    return segValues.size > 1;
+}
+function sameSegmentationEditionGroup(a, b) {
+    if (!isSegmentationEditionElement(a) || !isSegmentationEditionElement(b)) {
+        return false;
+    }
+    const aRef = a.token;
+    const bRef = b.token;
+    return (aRef.uid === bRef.uid &&
+        segmentationGroupKey(aRef) === segmentationGroupKey(bRef));
+}
+export function findSegmentationGroupBounds(elements, index) {
+    if (!isSegmentationEditionElement(elements[index])) {
+        return { start: index, end: index };
+    }
+    let start = index;
+    while (start > 0 &&
+        sameSegmentationEditionGroup(elements[start - 1], elements[index])) {
+        start -= 1;
+    }
+    let end = index;
+    while (end < elements.length - 1 &&
+        sameSegmentationEditionGroup(elements[end + 1], elements[index])) {
+        end += 1;
+    }
+    return { start, end };
+}
+function getLastSegmentationPosInGroup(elements, start, end) {
+    let lastP = elements[start].token.p;
+    for (let i = start + 1; i <= end; i += 1) {
+        const p = elements[i].token?.p;
+        if (p !== undefined && p > lastP) {
+            lastP = p;
+        }
+    }
+    return lastP;
+}
+export function shouldSkipSegmentationElement(elements, index, selectedTier, corpus) {
+    if (!isUnderSelected(selectedTier, SEGMENTATION_TIER, corpus)) {
+        return false;
+    }
+    const element = elements[index];
+    if (!isSegmentationEditionElement(element)) {
+        return false;
+    }
+    const { start, end } = findSegmentationGroupBounds(elements, index);
+    const lastP = getLastSegmentationPosInGroup(elements, start, end);
+    return element.token.p < lastP;
+}
+/** @deprecated Use shouldSkipSegmentationElement */
+export function shouldSkipSegmentationToken(elements, index, selectedTier, corpus) {
+    return shouldSkipSegmentationElement(elements, index, selectedTier, corpus);
+}
+export default function collapseElementsForTier(elements, selectedTier, corpus) {
+    const showJunctionSplits = isUnderSelected(selectedTier, JUNCTION_TIER, corpus);
+    const collapsed = [];
+    let index = 0;
+    while (index < elements.length) {
+        const element = elements[index];
+        if (shouldSkipSegmentationElement(elements, index, selectedTier, corpus)) {
+            index += 1;
+            continue;
+        }
+        if (shouldSkipJunctionContinuationElement(elements, index, selectedTier, corpus)) {
+            index += 1;
+            continue;
+        }
+        if (!showJunctionSplits &&
+            element.type === PageRenderElementType.JUNCTION_SPLIT &&
+            element.token) {
+            const token = element.token;
+            let end = index + 1;
+            while (end < elements.length &&
+                sameJunctionGroup(element, elements[end])) {
+                end += 1;
+            }
+            collapsed.push({
+                kind: 'collapsedJunction',
+                token,
+                splitIdx: element.idx ?? 0,
+                key: `junction_${token.uid}_${token.p}_${index}`,
+            });
+            index = end;
+            continue;
+        }
+        collapsed.push({
+            kind: 'single',
+            element,
+            key: `${element.type}_${index}`,
+        });
+        index += 1;
+    }
+    return collapsed;
+}
+export function isTokenBearingCollapsed(item) {
+    if (item.kind === 'collapsedJunction')
+        return true;
+    const { element } = item;
+    return (element.type === PageRenderElementType.TOKEN ||
+        element.type === PageRenderElementType.JUNCTION_SPLIT);
+}

package/dist/features/PageRender/editionTierOrder.d.ts

@@ -0,0 +1,16 @@
+import type { Corpus } from '../../configs/types/Corpus';
+export declare const SEGMENTATION_TIER = "seg";
+export declare const JUNCTION_TIER = "jun";
+export declare function getEditionTierOrder(corpus?: Corpus | null): readonly string[];
+/** Default display order (structural prefix + default corpus tiers). */
+export declare const EDITION_TIER_ORDER: readonly string[];
+export declare function isUnderSelected(selected: string, tier: string, corpus?: Corpus | null): boolean;
+/** Highest edition tier present on the token from junction down to the selected tier. */
+export declare function resolveHighestEditionTierForDisplay(ops: Record<string, string> | undefined, selectedTier: string, corpus?: Corpus | null): string | null;
+/** Alias: highest tier from junction through the selected tier (inclusive). */
+export declare function resolveEffectiveEditionTierForDisplay(ops: Record<string, string> | undefined, selectedTier: string, corpus?: Corpus | null): string | null;
+/**
+ * Junction + segmentation with no higher edition up to the selected tier → segmentation display.
+ * When e.g. padronization exists above segmentation, that layer is shown instead.
+ */
+export declare function shouldApplySegmentationOverJunction(ops: Record<string, string> | undefined, selectedTier: string, corpus?: Corpus | null): boolean;

package/dist/features/PageRender/editionTierOrder.js

@@ -0,0 +1,48 @@
+import EditionTierUtils from '../../functions/EditionTierUtils';
+export const SEGMENTATION_TIER = 'seg';
+export const JUNCTION_TIER = 'jun';
+export function getEditionTierOrder(corpus) {
+    return EditionTierUtils.getDisplayTierOrder(corpus);
+}
+/** Default display order (structural prefix + default corpus tiers). */
+export const EDITION_TIER_ORDER = getEditionTierOrder(null);
+export function isUnderSelected(selected, tier, corpus) {
+    const order = getEditionTierOrder(corpus);
+    const s = order.indexOf(selected);
+    const t = order.indexOf(tier);
+    if (s === -1 || t === -1)
+        return false;
+    return s < t;
+}
+/** Highest edition tier present on the token from junction down to the selected tier. */
+export function resolveHighestEditionTierForDisplay(ops, selectedTier, corpus) {
+    const order = getEditionTierOrder(corpus);
+    const selectedIdx = order.indexOf(selectedTier);
+    if (selectedIdx <= 0)
+        return null;
+    let effective = null;
+    for (let i = 1; i <= selectedIdx; i += 1) {
+        const tier = order[i];
+        if (ops?.[tier] !== undefined) {
+            effective = tier;
+        }
+    }
+    return effective;
+}
+/** Alias: highest tier from junction through the selected tier (inclusive). */
+export function resolveEffectiveEditionTierForDisplay(ops, selectedTier, corpus) {
+    return resolveHighestEditionTierForDisplay(ops, selectedTier, corpus);
+}
+/**
+ * Junction + segmentation with no higher edition up to the selected tier → segmentation display.
+ * When e.g. padronization exists above segmentation, that layer is shown instead.
+ */
+export function shouldApplySegmentationOverJunction(ops, selectedTier, corpus) {
+    if (ops?.[JUNCTION_TIER] === undefined ||
+        ops?.[SEGMENTATION_TIER] === undefined ||
+        isUnderSelected(selectedTier, SEGMENTATION_TIER, corpus)) {
+        return false;
+    }
+    return (resolveEffectiveEditionTierForDisplay(ops, selectedTier, corpus) ===
+        SEGMENTATION_TIER);
+}

package/dist/features/PageRender/index.d.ts

@@ -0,0 +1,4 @@
+export { default as PageRenderView } from './PageRenderView';
+export { default as collapseElementsForTier } from './collapseElementsForTier';
+export { tokenRefToToken, default as isTokenRefVisible } from './tokenUtils';
+export * from './types';

package/dist/features/PageRender/index.js

@@ -0,0 +1,4 @@
+export { default as PageRenderView } from './PageRenderView';
+export { default as collapseElementsForTier } from './collapseElementsForTier';
+export { tokenRefToToken, default as isTokenRefVisible } from './tokenUtils';
+export * from './types';

package/dist/features/PageRender/tokenUtils.d.ts

@@ -0,0 +1,4 @@
+import type { Token } from '../../configs/types/Struct';
+import type { TokenRef } from './types';
+export default function isTokenRefVisible(ref: TokenRef): boolean;
+export declare function tokenRefToToken(ref: TokenRef): Token;

package/dist/features/PageRender/tokenUtils.js

@@ -0,0 +1,28 @@
+export default function isTokenRefVisible(ref) {
+    return ref.v !== '' && (!ref.ec || (ref.ec && !!ref.split));
+}
+export function tokenRefToToken(ref) {
+    const token = {
+        tid: ref.tid,
+        p: ref.p,
+        v: ref.v,
+        t: ref.t,
+        edited: ref.edited,
+        cid: ref.cid,
+        bid: ref.bid,
+        mid: ref.mid,
+        ns: ref.ns,
+        review: ref.review,
+        ec: ref.ec,
+        edition: ref.edition,
+        format: ref.format,
+        split: ref.split,
+    };
+    if (ref.edition) {
+        token.edition = ref.edition;
+        if (ref.edited) {
+            token.eid = ref.edition.id || 'edition';
+        }
+    }
+    return token;
+}

package/dist/features/PageRender/types.d.ts

@@ -0,0 +1,62 @@
+import type { ReactNode } from 'react';
+import type { Corpus } from '../../configs/types/Corpus';
+import type Document from '../../configs/types/Document';
+import type { Edition, Format, Split, Token } from '../../configs/types/Struct';
+export declare enum PageRenderElementType {
+    MARK = "MARK",
+    TOKEN = "TOKEN",
+    JUNCTION_SPLIT = "JUNCTION_SPLIT",
+    LINE_BREAK = "LINE_BREAK",
+    LINE_NUMBER = "LINE_NUMBER",
+    PARTICIPANT = "PARTICIPANT"
+}
+export type TokenRef = {
+    uid: string;
+    tid?: string;
+    p: number;
+    v: string;
+    t?: string;
+    edited?: boolean;
+    cid?: string;
+    bid?: string;
+    mid?: string;
+    ns?: boolean;
+    review?: boolean;
+    ec?: boolean;
+    edition?: Edition;
+    format?: Format;
+    split?: Split;
+};
+export type PageRenderElement = {
+    type: PageRenderElementType;
+    idx?: number;
+    line?: number;
+    mstart?: boolean;
+    participant?: string;
+    token?: TokenRef;
+};
+export type CollapsedPageRenderElement = {
+    kind: 'single';
+    element: PageRenderElement;
+    key: string;
+} | {
+    kind: 'collapsedJunction';
+    token: TokenRef;
+    splitIdx?: number;
+    key: string;
+};
+export type PageRenderViewProps = {
+    elements: PageRenderElement[];
+    selectedTier: string;
+    corpus?: Corpus | null;
+    document?: Document | null;
+    displayTags?: boolean;
+    showLineNumbers?: boolean;
+    highlightSentenceUid?: string;
+    getDisplayValue: (token: Token, splitIdx?: number) => ReactNode;
+    getTokenStyle?: (token: Token) => React.CSSProperties;
+    isTokenEdited?: (token: Token) => boolean;
+    getParticipantName?: (code: string) => string;
+    getParticipantColor?: (code: string) => string;
+    onTokenClick?: (ref: TokenRef, splitIdx?: number) => void;
+};

package/dist/features/PageRender/types.js

@@ -0,0 +1,9 @@
+export var PageRenderElementType;
+(function (PageRenderElementType) {
+    PageRenderElementType["MARK"] = "MARK";
+    PageRenderElementType["TOKEN"] = "TOKEN";
+    PageRenderElementType["JUNCTION_SPLIT"] = "JUNCTION_SPLIT";
+    PageRenderElementType["LINE_BREAK"] = "LINE_BREAK";
+    PageRenderElementType["LINE_NUMBER"] = "LINE_NUMBER";
+    PageRenderElementType["PARTICIPANT"] = "PARTICIPANT";
+})(PageRenderElementType || (PageRenderElementType = {}));

package/dist/features/index.d.ts

@@ -13,3 +13,5 @@ export type { SearchCriteria } from "./TreeView/TreeViewSearch/TreeViewSearch";
 export { default as CytoscapeMenuCanvas } from "./CytoscapeMenu/CytoscapeMenuCanvas";
 export { registerCytoscapeContextMenus, contextMenus } from "./CytoscapeMenu";
 export type { CytoscapeContextMenuOptions, MenuItemOption, ContextMenusInstance, } from "./CytoscapeMenu";
+export { PageRenderView, collapseElementsForTier, tokenRefToToken, isTokenRefVisible, } from "./PageRender";
+export type { PageRenderElement, PageRenderElementType, PageRenderViewProps, TokenRef, CollapsedPageRenderElement, } from "./PageRender";

package/dist/features/index.js

@@ -9,3 +9,4 @@ export { default as SyntreesCytoscape } from "./TreeView/cytoscape/SyntreesCytos
 export { default as TreeViewSearch } from "./TreeView/TreeViewSearch/TreeViewSearch";
 export { default as CytoscapeMenuCanvas } from "./CytoscapeMenu/CytoscapeMenuCanvas";
 export { registerCytoscapeContextMenus, contextMenus } from "./CytoscapeMenu";
+export { PageRenderView, collapseElementsForTier, tokenRefToToken, isTokenRefVisible, } from "./PageRender";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tycho-components",
   "private": false,
-  "version": "0.36.10",
+  "version": "0.37.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -82,7 +82,7 @@
     "react-i18next": "^13.0.2",
     "react-router-dom": "^6.14.2",
     "react-toastify": "^9.1.3",
-    "tycho-storybook": "0.10.13",
+    "tycho-storybook": "0.10.15",
     "wavesurfer-react": "^2.2.2",
     "wavesurfer.js": "^6.6.3"
   },
@@ -111,7 +111,7 @@
     "react-toastify": "^9.1.3",
     "sass-embedded": "^1.97.2",
     "storybook": "^10.1.11",
-    "tycho-storybook": "^0.10.13",
+    "tycho-storybook": "^0.10.15",
     "typescript": "^5.7.3",
     "vite": "^7.0.0",
     "vitest": "^3.2.6",