tycho-components 0.26.1 → 0.27.0

package/dist/configs/index.d.ts

@@ -12,7 +12,8 @@ export { DocumentStatusNames } from './types/Document';
 export type { DocumentStatus, default as Document } from './types/Document';
 export { CorpusImageTypeNames } from './types/CorpusImage';
 export type { CorpusImage, CorpusImageType } from './types/CorpusImage';
-export { EditionTiers } from './types/EditionTiers';
+export { DEFAULT_EDITION_TIERS, EditionTiers, StructuralEditionTiers, isStructuralEditionTier, } from './types/EditionTiers';
+export type { EditionGroup, EditionTierDefinition, EditionTierGroup, EditionTierSymbol, } from './types/EditionTiers';
 export type { Parameter, ParameterType } from './types/Parameter';
 export { SentenceStatusNames } from './types/SentenceStatus';
 export type { SentenceStatus } from './types/SentenceStatus';

package/dist/configs/index.js

@@ -8,7 +8,7 @@ export { default as ProfileService } from './services/ProfileService';
 export { CorpusStatusNames } from './types/CorpusStatus';
 export { DocumentStatusNames } from './types/Document';
 export { CorpusImageTypeNames } from './types/CorpusImage';
-export { EditionTiers } from './types/EditionTiers';
+export { DEFAULT_EDITION_TIERS, EditionTiers, StructuralEditionTiers, isStructuralEditionTier, } from './types/EditionTiers';
 export { SentenceStatusNames } from './types/SentenceStatus';
 export { UserStatusNames } from './types/User';
 export { useCorpusUtils } from './useCorpusUtils';

package/dist/configs/localization/ParametersTexts.js

@@ -27,8 +27,8 @@ export const ParametersTexts = {
         "parameter.tooltip.useParticipantChat": "With this feature enabled, it is possible to add extra standard attributes to participants of transcriptions, as defined by the CHAT format com CHILDES project.",
         "parameter.field.useSplit": "Enable Morpheme Edition",
         "parameter.tooltip.useSplit": "Enables the use of fields related to morphemes in the corpora.",
-        "parameter.field.useEditionTiers": "Enable Default Edition Tiers",
-        "parameter.tooltip.useEditionTiers": "Enables the use of edition tiers to ensure maximum philological fidelity of the text.",
+        "parameter.field.useEditionTiers": "Enable Edition Tiers",
+        "parameter.tooltip.useEditionTiers": "Enables edition operations in the editor, including junction, segmentation, and configurable corpus edition tiers.",
         "parameter.field.allowPosTagInclusion": "Allow POS Tag inclusion",
         "parameter.tooltip.allowPosTagInclusion": "With this feature enabled, it is possible to add new POS tags to the list while editing sentences in the editor. A parser must be associated to the corpus.",
         "parameter.field.useGrid": "Display Documents in Grid",
@@ -67,8 +67,8 @@ export const ParametersTexts = {
         "parameter.tooltip.useParticipantChat": "Com este recurso habilitado, é possível adicionar atributos padrão extras aos participantes de transcrições, conforme definido pelo formato CHAT com o projeto CHILDES.",
         "parameter.field.useSplit": "Habilitar Edição de Morfema",
         "parameter.tooltip.useSplit": "Habilita o uso de campos relacionados a morfemas nos corpora.",
-        "parameter.field.useEditionTiers": "Habilitar Níveis de Edição Padrão",
-        "parameter.tooltip.useEditionTiers": "Habilita o uso de níveis de edição para garantir máxima fidelidade filológica do texto.",
+        "parameter.field.useEditionTiers": "Habilitar Níveis de Edição",
+        "parameter.tooltip.useEditionTiers": "Habilita operações de edição no editor, incluindo junção, segmentação e níveis de edição configuráveis do corpus.",
         "parameter.field.allowPosTagInclusion": "Permitir Inclusão de Tag POS",
         "parameter.tooltip.allowPosTagInclusion": "Com este recurso habilitado, é possível adicionar novas tags POS à lista durante a edição de frases no editor. Um parser deve estar associado ao corpus.",
         "parameter.field.useGrid": "Exibir Documentos em Grade",
@@ -107,8 +107,8 @@ export const ParametersTexts = {
         "parameter.tooltip.useParticipantChat": "Con questa funzione abilitata, è possibile aggiungere attributi standard extra ai partecipanti delle trascrizioni, come definito dal formato CHAT con il progetto CHILDES.",
         "parameter.field.useSplit": "Abilita Modifica Morfemi",
         "parameter.tooltip.useSplit": "Abilita l'uso di campi relativi ai morfemi nei corpora.",
-        "parameter.field.useEditionTiers": "Abilita Livelli di Edizione Predefiniti",
-        "parameter.tooltip.useEditionTiers": "Abilita l'uso di livelli di edizione per garantire la massima fedeltà filologica del testo.",
+        "parameter.field.useEditionTiers": "Abilita Livelli di Edizione",
+        "parameter.tooltip.useEditionTiers": "Abilita le operazioni di edizione nell'editor, inclusi giunzione, segmentazione e livelli di edizione configurabili del corpus.",
         "parameter.field.allowPosTagInclusion": "Permetti Inclusione Tag POS",
         "parameter.tooltip.allowPosTagInclusion": "Con questa funzione abilitata, è possibile aggiungere nuovi tag POS all'elenco durante l'editing delle frasi in editor. Un parser deve essere associato al corpus.",
         "parameter.field.useGrid": "Visualizza Documenti a Griglia",

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

@@ -1,5 +1,6 @@
 import { CorpusImage } from './CorpusImage';
 import { CorpusStatus } from './CorpusStatus';
+import { EditionTierDefinition } from './EditionTiers';
 import { User } from './User';
 export type Corpus = {
     id?: number;
@@ -8,6 +9,7 @@ export type Corpus = {
     picture: string;
     uploadDir: string;
     parameters: Record<string, any>;
+    editionTiers?: EditionTierDefinition[];
     status: CorpusStatus;
     opened: boolean;
     featured?: boolean;

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

@@ -1,13 +1,36 @@
-export declare enum EditionTiers {
-    ORIGINAL = "ori",
-    JUNCTION = "jun",
-    SEGMENTATION = "seg",
-    SPELLING = "gra",
-    EXPANSION = "exp",
-    CORRECTION = "cor",
-    PUNCTUATION = "pon",
-    ILLEGIBLE = "ileg",
-    MODERNIZATION = "mod",
-    PADRONIZATION = "pad",
-    INFLECTION = "fle"
-}
+export type EditionTierGroup = 'semiDiplomatic' | 'modernized';
+export type EditionTierDefinition = {
+    symbol: string;
+    label: string;
+    order: number;
+    group: EditionTierGroup;
+    abbreviation: boolean;
+};
+export declare const StructuralEditionTiers: {
+    readonly ORIGINAL: "ori";
+    readonly JUNCTION: "jun";
+    readonly SEGMENTATION: "seg";
+};
+/** Default configurable tier symbols (structural ops are excluded). */
+export declare const EditionTiers: {
+    readonly ORIGINAL: "ori";
+    readonly JUNCTION: "jun";
+    readonly SEGMENTATION: "seg";
+    readonly SPELLING: "gra";
+    readonly EXPANSION: "exp";
+    readonly CORRECTION: "cor";
+    readonly PUNCTUATION: "pon";
+    readonly ILLEGIBLE: "ileg";
+    readonly MODERNIZATION: "mod";
+    readonly PADRONIZATION: "pad";
+    readonly INFLECTION: "fle";
+};
+export type EditionTierSymbol = (typeof EditionTiers)[keyof typeof EditionTiers];
+export declare const DEFAULT_EDITION_TIERS: EditionTierDefinition[];
+export type EditionGroup = {
+    id: string;
+    labelKey: string;
+    tiers: string[];
+    defaultTier: string;
+};
+export declare const isStructuralEditionTier: (symbol: string) => boolean;

package/dist/configs/types/EditionTiers.js

@@ -1,14 +1,83 @@
-export var EditionTiers;
-(function (EditionTiers) {
-    EditionTiers["ORIGINAL"] = "ori";
-    EditionTiers["JUNCTION"] = "jun";
-    EditionTiers["SEGMENTATION"] = "seg";
-    EditionTiers["SPELLING"] = "gra";
-    EditionTiers["EXPANSION"] = "exp";
-    EditionTiers["CORRECTION"] = "cor";
-    EditionTiers["PUNCTUATION"] = "pon";
-    EditionTiers["ILLEGIBLE"] = "ileg";
-    EditionTiers["MODERNIZATION"] = "mod";
-    EditionTiers["PADRONIZATION"] = "pad";
-    EditionTiers["INFLECTION"] = "fle";
-})(EditionTiers || (EditionTiers = {}));
+export const StructuralEditionTiers = {
+    ORIGINAL: 'ori',
+    JUNCTION: 'jun',
+    SEGMENTATION: 'seg',
+};
+/** Default configurable tier symbols (structural ops are excluded). */
+export const EditionTiers = {
+    ORIGINAL: 'ori',
+    JUNCTION: 'jun',
+    SEGMENTATION: 'seg',
+    SPELLING: 'gra',
+    EXPANSION: 'exp',
+    CORRECTION: 'cor',
+    PUNCTUATION: 'pon',
+    ILLEGIBLE: 'ileg',
+    MODERNIZATION: 'mod',
+    PADRONIZATION: 'pad',
+    INFLECTION: 'fle',
+};
+export const DEFAULT_EDITION_TIERS = [
+    {
+        symbol: EditionTiers.SPELLING,
+        label: 'Spelling',
+        order: 1,
+        group: 'semiDiplomatic',
+        abbreviation: false,
+    },
+    {
+        symbol: EditionTiers.EXPANSION,
+        label: 'Expansion',
+        order: 2,
+        group: 'semiDiplomatic',
+        abbreviation: true,
+    },
+    {
+        symbol: EditionTiers.CORRECTION,
+        label: 'Correction',
+        order: 3,
+        group: 'semiDiplomatic',
+        abbreviation: false,
+    },
+    {
+        symbol: EditionTiers.PUNCTUATION,
+        label: 'Punctuation',
+        order: 4,
+        group: 'semiDiplomatic',
+        abbreviation: false,
+    },
+    {
+        symbol: EditionTiers.ILLEGIBLE,
+        label: 'Illegible',
+        order: 5,
+        group: 'semiDiplomatic',
+        abbreviation: false,
+    },
+    {
+        symbol: EditionTiers.MODERNIZATION,
+        label: 'Modernization',
+        order: 6,
+        group: 'modernized',
+        abbreviation: false,
+    },
+    {
+        symbol: EditionTiers.PADRONIZATION,
+        label: 'Padronization',
+        order: 7,
+        group: 'modernized',
+        abbreviation: false,
+    },
+    {
+        symbol: EditionTiers.INFLECTION,
+        label: 'Inflection',
+        order: 8,
+        group: 'modernized',
+        abbreviation: false,
+    },
+];
+const RESERVED_SYMBOLS = new Set([
+    StructuralEditionTiers.ORIGINAL,
+    StructuralEditionTiers.JUNCTION,
+    StructuralEditionTiers.SEGMENTATION,
+]);
+export const isStructuralEditionTier = (symbol) => RESERVED_SYMBOLS.has(symbol);

package/dist/configs/useMessageUtils.d.ts

@@ -13,7 +13,7 @@ export declare const useMessageUtils: () => {
     dispatchLoading: (val: boolean, text?: string) => void;
     dispatchError: ({ err, t, key }: ErrorDispatcher) => void;
     dispatchMessage: ({ key, ns, t }: MessageDispatcher) => void;
-    dispatchMessageDirect: (value: string, type?: "success" | "error") => void;
+    dispatchMessageDirect: (value: string, type?: "success" | "error" | "warning") => void;
     isLoading: () => boolean;
     dispatchSilent: (val: boolean) => void;
     isSilentLoading: () => boolean;

package/dist/features/SentenceView/SentenceEditionTiers.d.ts

@@ -1,8 +1,10 @@
+import { Corpus } from '../../configs/types/Corpus';
 import { Token } from '../../configs/types/Struct';
 import './style.scss';
 type Props = {
     tokens: Token[];
     displayOriginal?: boolean;
+    corpus?: Corpus | null;
 };
-export default function SentenceEditionTiers({ tokens, displayOriginal, }: Props): import("react/jsx-runtime").JSX.Element;
+export default function SentenceEditionTiers({ tokens, displayOriginal, corpus, }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/features/SentenceView/SentenceEditionTiers.js

@@ -3,25 +3,22 @@ import { useTranslation } from 'react-i18next';
 import EditionTierUtils from '../../functions/EditionTierUtils';
 import SentenceUtils from '../../functions/SentenceUtils';
 import './style.scss';
-export default function SentenceEditionTiers({ tokens, displayOriginal, }) {
+export default function SentenceEditionTiers({ tokens, displayOriginal, corpus, }) {
     const { t } = useTranslation('sentence');
     const { skipToken } = SentenceUtils;
-    const { getIterateTiers, getEditionTierName, getEditionForToken, getOriginalValue, } = EditionTierUtils;
+    const { getIterateTiers, getTierLabel, getEditionForToken, getOriginalValue, } = EditionTierUtils;
     return (_jsxs(_Fragment, { children: [displayOriginal && (_jsxs("tr", { className: "word-tier", children: [_jsx("td", { children: t('label.tier.original') }), tokens.map((thisToken, idy) => {
                         if (skipToken(thisToken)) {
                             return true;
                         }
                         const value = getOriginalValue(thisToken);
-                        return (_jsx("td", { className: "text-center", colSpan: thisToken.splits ? thisToken.splits.length : 1, children: _jsx("span", { className: value ? '' : 'empty', children: value || t('label.empty') }) }));
-                    })] })), getIterateTiers().map((tier, idx) => {
-                const key = getEditionTierName(tier);
-                return (_jsxs("tr", { className: "word-tier", children: [_jsx("td", { children: t(`label.tier.${key.toLowerCase()}`) }), tokens.map((thisToken, idy) => {
-                            if (skipToken(thisToken)) {
-                                return true;
-                            }
-                            const tierEdition = getEditionForToken(thisToken);
-                            const value = (tierEdition?.ops || {})[tier] || '';
-                            return (_jsx("td", { className: "text-center", colSpan: thisToken.splits ? thisToken.splits.length : 1, children: _jsx("span", { className: value ? '' : 'empty', children: value || t('label.empty') }) }, `${thisToken.p}_${idx.valueOf()}_${idy.valueOf()}`));
-                        })] }, idx.valueOf()));
-            })] }));
+                        return (_jsx("td", { className: "text-center", colSpan: thisToken.splits ? thisToken.splits.length : 1, children: _jsx("span", { className: value ? '' : 'empty', children: value || t('label.empty') }) }, `original_${thisToken.p}_${idy}`));
+                    })] })), getIterateTiers(corpus).map((tier, idx) => (_jsxs("tr", { className: "word-tier", children: [_jsx("td", { children: getTierLabel(tier, corpus, t) }), tokens.map((thisToken, idy) => {
+                        if (skipToken(thisToken)) {
+                            return true;
+                        }
+                        const tierEdition = getEditionForToken(thisToken);
+                        const value = (tierEdition?.ops || {})[tier] || '';
+                        return (_jsx("td", { className: "text-center", colSpan: thisToken.splits ? thisToken.splits.length : 1, children: _jsx("span", { className: value ? '' : 'empty', children: value || t('label.empty') }) }, `${thisToken.p}_${idx}_${idy}`));
+                    })] }, tier)))] }));
 }

package/dist/features/SentenceView/SentenceView.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCorpusUtils } from '../../configs/useCorpusUtils';
 import SentenceUtils from '../../functions/SentenceUtils';
 import SentenceEditionTiers from './SentenceEditionTiers';
 import SentenceMorphemeTiers from './SentenceMorphemeTiers';
@@ -8,5 +9,6 @@ import SentenceWordTiers from './SentenceWordTiers';
 import './style.scss';
 export default function SentenceView({ wordTiers, morphemeTiers, struct, useMorphemes, useEditionTiers, displayOriginal, }) {
     const tokens = SentenceUtils.sort(struct);
-    return (_jsx("div", { className: "sentence-view-container", children: _jsx("div", { className: "body", children: _jsx("table", { className: "table table-striped", children: _jsxs("tbody", { children: [_jsx(SentenceValues, { tokens: tokens }), _jsx(SentenceTags, { tokens: tokens }), useEditionTiers && (_jsx(SentenceEditionTiers, { tokens: tokens, displayOriginal: displayOriginal })), wordTiers && (_jsx(SentenceWordTiers, { tokens: tokens, wordTiers: wordTiers })), useMorphemes && morphemeTiers && (_jsx(SentenceMorphemeTiers, { struct: struct, morphemeTiers: morphemeTiers }))] }) }) }) }));
+    const { getCorpus } = useCorpusUtils();
+    return (_jsx("div", { className: "sentence-view-container", children: _jsx("div", { className: "body", children: _jsx("table", { className: "table table-striped", children: _jsxs("tbody", { children: [_jsx(SentenceValues, { tokens: tokens }), _jsx(SentenceTags, { tokens: tokens }), useEditionTiers && (_jsx(SentenceEditionTiers, { tokens: tokens, displayOriginal: displayOriginal, corpus: getCorpus() })), wordTiers && (_jsx(SentenceWordTiers, { tokens: tokens, wordTiers: wordTiers })), useMorphemes && morphemeTiers && (_jsx(SentenceMorphemeTiers, { struct: struct, morphemeTiers: morphemeTiers }))] }) }) }) }));
 }

package/dist/features/TreeView/cytoscape/CytoscapeTreeConverter.js

@@ -228,7 +228,14 @@ export default class CytoscapeTreeConverter {
         return `${token.p}`;
     }
     findParent(struct, chunk) {
-        return this.tightestChunk(this.findContainingChunks(struct, chunk.l - 1, chunk.i, chunk.f));
+        if (chunk.l <= 0)
+            return null;
+        for (let level = chunk.l - 1; level >= 0; level--) {
+            const parent = this.tightestChunk(this.findContainingChunks(struct, level, chunk.i, chunk.f));
+            if (parent)
+                return parent;
+        }
+        return null;
     }
     findContainingChunks(struct, level, i, f) {
         return struct.chunks.filter((c) => c.l === level && i >= c.i && f <= c.f);

package/dist/features/TreeView/cytoscape/SyntreesCytoscape.d.ts

@@ -1,5 +1,9 @@
-import cytoscape, { Core } from 'cytoscape';
+import cytoscape, { Core, Position } from 'cytoscape';
 import { CytoscapeTree } from '../../../configs/types/Tree';
+export type CytoscapeViewport = {
+    zoom: number;
+    pan: Position;
+};
 type Props = {
     selector: string;
     tree: CytoscapeTree;
@@ -8,8 +12,10 @@ type Props = {
     wheelSensitivity?: number;
     onReady?: (cy: Core) => void;
     autoungrabify?: boolean;
+    fit?: boolean;
+    viewport?: CytoscapeViewport;
 };
 declare const SyntreesCytoscape: {
-    init: ({ selector, tree, dagre, stylesheet, wheelSensitivity, onReady, autoungrabify, }: Props) => Core;
+    init: ({ selector, tree, dagre, stylesheet, wheelSensitivity, onReady, autoungrabify, fit, viewport, }: Props) => Core;
 };
 export default SyntreesCytoscape;

package/dist/features/TreeView/cytoscape/SyntreesCytoscape.js

@@ -3,7 +3,7 @@ import defaultStylesheet from './CytoscapeStylesheet';
 // @ts-ignore
 import nodeHtmlLabel from 'cytoscape-node-html-label';
 nodeHtmlLabel(cytoscape);
-const init = ({ selector, tree, dagre = false, stylesheet = defaultStylesheet, wheelSensitivity = 1.5, onReady, autoungrabify = true, }) => {
+const init = ({ selector, tree, dagre = false, stylesheet = defaultStylesheet, wheelSensitivity = 1.5, onReady, autoungrabify = true, fit = true, viewport, }) => {
     destroy(selector);
     const cy = cytoscape({
         container: document.getElementById(selector),
@@ -57,8 +57,14 @@ const init = ({ selector, tree, dagre = false, stylesheet = defaultStylesheet, w
             ]);
             cy._htmlLabelsApplied = true;
         }
-        cy.fit();
-        cy.center();
+        if (fit) {
+            cy.fit();
+            cy.center();
+        }
+        else if (viewport) {
+            cy.zoom(viewport.zoom);
+            cy.pan(viewport.pan);
+        }
         dagre && cy.layout({ name: 'dagre' }).run();
         onReady && onReady(cy);
     });

package/dist/functions/EditionTierUtils.d.ts

@@ -1,9 +1,22 @@
-import { EditionTiers } from '../configs/types/EditionTiers';
+import { EditionGroup, EditionTierDefinition } from '../configs/types/EditionTiers';
+import { Corpus } from '../configs/types/Corpus';
 import { Token } from '../configs/types/Struct';
 declare const EditionTierUtils: {
-    getIterateTiers: () => EditionTiers[];
-    getEditionTierName: (k: string) => string;
+    getCorpusEditionTiers: (corpus?: Corpus | null) => EditionTierDefinition[];
+    normalizeOrder: (tiers: EditionTierDefinition[]) => EditionTierDefinition[];
+    getIterateTiers: (corpus?: Corpus | null) => string[];
+    getAbbreviationTiers: (corpus?: Corpus | null) => string[];
+    getParserTier: (corpus?: Corpus | null) => EditionTierDefinition | undefined;
+    getEditionTierName: (symbol: string) => string;
+    getTierLabel: (symbol: string, corpus?: Corpus | null, t?: (key: string) => string) => string;
+    isUnderSelected: (selected: string, tier: string, corpus?: Corpus | null) => boolean;
+    buildEditionGroups: (corpus?: Corpus | null) => EditionGroup[];
+    findGroupForTier: (tier: string, corpus?: Corpus | null) => EditionGroup | undefined;
+    isAbbreviationTier: (symbol: string, corpus?: Corpus | null) => boolean;
+    validateEditionTiers: (tiers: EditionTierDefinition[]) => string | null;
+    isDefaultTierSymbol: (symbol: string) => boolean;
     getEditionForToken: (token: Token) => any;
     getOriginalValue: (token: Token) => string;
+    getDisplayTierOrder: (corpus?: Corpus | null) => string[];
 };
 export default EditionTierUtils;

package/dist/functions/EditionTierUtils.js

@@ -1,4 +1,95 @@
-import { EditionTiers } from '../configs/types/EditionTiers';
+import { DEFAULT_EDITION_TIERS, EditionTiers, StructuralEditionTiers, isStructuralEditionTier, } from '../configs/types/EditionTiers';
+const DEFAULT_SYMBOLS = new Set(DEFAULT_EDITION_TIERS.map((tier) => tier.symbol));
+const getCorpusEditionTiers = (corpus) => {
+    if (!corpus?.editionTiers?.length) {
+        return DEFAULT_EDITION_TIERS.map((tier) => ({ ...tier }));
+    }
+    return [...corpus.editionTiers].sort((a, b) => a.order - b.order);
+};
+const normalizeOrder = (tiers) => tiers.map((tier, index) => ({ ...tier, order: index + 1 }));
+const getIterateTiers = (corpus) => getCorpusEditionTiers(corpus).map((tier) => tier.symbol);
+const getAbbreviationTiers = (corpus) => getCorpusEditionTiers(corpus)
+    .filter((tier) => tier.abbreviation)
+    .map((tier) => tier.symbol);
+const getParserTier = (corpus) => {
+    const tiers = getCorpusEditionTiers(corpus);
+    return tiers[tiers.length - 1];
+};
+const getEditionTierName = (symbol) => {
+    const entry = Object.entries(EditionTiers).find(([, value]) => value === symbol);
+    return entry?.[0] || symbol;
+};
+const getTierLabel = (symbol, corpus, t) => {
+    const definition = getCorpusEditionTiers(corpus).find((tier) => tier.symbol === symbol);
+    if (definition?.label) {
+        return definition.label;
+    }
+    const key = getEditionTierName(symbol).toLowerCase();
+    if (t) {
+        return t(`sentence:label.tier.${key}`);
+    }
+    return key;
+};
+const isUnderSelected = (selected, tier, corpus) => {
+    const tiers = getIterateTiers(corpus);
+    const selectedIndex = tiers.indexOf(selected);
+    const tierIndex = tiers.indexOf(tier);
+    if (selectedIndex === -1 || tierIndex === -1) {
+        return false;
+    }
+    return tierIndex <= selectedIndex;
+};
+const buildEditionGroups = (corpus) => {
+    const tiers = getCorpusEditionTiers(corpus);
+    const semi = tiers
+        .filter((tier) => tier.group === 'semiDiplomatic')
+        .map((tier) => tier.symbol);
+    const modern = tiers
+        .filter((tier) => tier.group === 'modernized')
+        .map((tier) => tier.symbol);
+    return [
+        {
+            id: 'diplomatic',
+            labelKey: 'edition.group.diplomatic',
+            tiers: [StructuralEditionTiers.ORIGINAL],
+            defaultTier: StructuralEditionTiers.ORIGINAL,
+        },
+        {
+            id: 'semiDiplomatic',
+            labelKey: 'edition.group.semiDiplomatic',
+            tiers: semi,
+            defaultTier: semi[semi.length - 1] || EditionTiers.ILLEGIBLE,
+        },
+        {
+            id: 'modernized',
+            labelKey: 'edition.group.modernized',
+            tiers: modern,
+            defaultTier: modern[modern.length - 1] || EditionTiers.INFLECTION,
+        },
+    ];
+};
+const findGroupForTier = (tier, corpus) => buildEditionGroups(corpus).find((group) => group.tiers.includes(tier));
+const isAbbreviationTier = (symbol, corpus) => getCorpusEditionTiers(corpus).some((tier) => tier.symbol === symbol && tier.abbreviation);
+const validateEditionTiers = (tiers) => {
+    const symbols = new Set();
+    for (const tier of tiers) {
+        if (!tier.symbol?.trim()) {
+            return 'edition.tiers.symbol.required';
+        }
+        if (isStructuralEditionTier(tier.symbol)) {
+            return 'edition.tiers.symbol.reserved';
+        }
+        if (symbols.has(tier.symbol)) {
+            return 'edition.tiers.duplicate.symbol';
+        }
+        symbols.add(tier.symbol);
+        if (tier.group !== 'semiDiplomatic' && tier.group !== 'modernized') {
+            return 'edition.tiers.group.invalid';
+        }
+    }
+    return null;
+};
+const isDefaultTierSymbol = (symbol) => DEFAULT_SYMBOLS.has(symbol);
 const getEditionForToken = (token) => {
     if (token.eid)
         return token.edition;
@@ -9,28 +100,29 @@ const getEditionForToken = (token) => {
     }));
     return { ...edition, o: token.v };
 };
-const getIterateTiers = () => {
-    const ordered = [];
-    for (const value of Object.values(EditionTiers)) {
-        const key = getEditionTierName(value);
-        if (key !== 'ORIGINAL' && key !== 'JUNCTION' && key !== 'SEGMENTATION') {
-            ordered.push(value);
-        }
-    }
-    return ordered;
-};
-const getEditionTierName = (k) => {
-    const idx = Object.values(EditionTiers).indexOf(k);
-    const key = Object.keys(EditionTiers)[idx];
-    return key || k;
-};
-const getOriginalValue = (token) => {
-    return token.edition?.o || '';
-};
+const getOriginalValue = (token) => token.edition?.o || '';
+const getDisplayTierOrder = (corpus) => [
+    StructuralEditionTiers.ORIGINAL,
+    StructuralEditionTiers.JUNCTION,
+    StructuralEditionTiers.SEGMENTATION,
+    ...getIterateTiers(corpus),
+];
 const EditionTierUtils = {
+    getCorpusEditionTiers,
+    normalizeOrder,
     getIterateTiers,
+    getAbbreviationTiers,
+    getParserTier,
     getEditionTierName,
+    getTierLabel,
+    isUnderSelected,
+    buildEditionGroups,
+    findGroupForTier,
+    isAbbreviationTier,
+    validateEditionTiers,
+    isDefaultTierSymbol,
     getEditionForToken,
     getOriginalValue,
+    getDisplayTierOrder,
 };
 export default EditionTierUtils;

package/dist/functions/SentenceUtils.js

@@ -1,4 +1,4 @@
-import { EditionTiers } from '../configs/types/EditionTiers';
+import EditionTierUtils from './EditionTierUtils';
 const getTag = (token) => {
     if (token.split)
         return token.split.t || '';
@@ -65,11 +65,7 @@ const isFirstFromSplit = (token) => {
         return false;
     return token.split.idx !== undefined && token.split.idx === 0;
 };
-const getEditionTierName = (k) => {
-    const idx = Object.values(EditionTiers).indexOf(k);
-    const key = Object.keys(EditionTiers)[idx];
-    return key || k;
-};
+const getEditionTierName = (k) => EditionTierUtils.getEditionTierName(k);
 const SentenceUtils = {
     sort,
     getAsText,

package/package.json

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