tycho-components 0.40.4 → 0.40.6

package/dist/functions/conllu/ConlluUtils.d.ts

@@ -0,0 +1,20 @@
+import { EdgeDefinition, NodeDefinition, Position } from 'cytoscape';
+import { Conllu, ConlluToken, Struct } from '../../configs';
+export type CytoscapeTree = {
+    nodes: NodeDefinition[];
+    edges: EdgeDefinition[];
+    pan?: Position;
+};
+declare const ConlluUtils: {
+    convertToSentence: (conllText: string) => Conllu;
+    convertToConllu: (conllu: Conllu) => string;
+    convertToCytoscape: (conllu: Conllu) => CytoscapeTree;
+    getAsText: (conllu: Conllu) => string;
+    convertStructToConllu: (struct: Struct) => Conllu;
+    extractConlluTokens: (conllText: string) => ConlluToken[];
+    isNotEmptyConllu: (conllu: Conllu) => boolean;
+    deleteToken: (conllu: Conllu, tokenIndex: number) => Conllu;
+    getConlluTranslationFromStruct: (struct: Struct | undefined, lang: string) => string;
+    generateImageFromSVG: (svgElement: SVGSVGElement) => void;
+};
+export default ConlluUtils;

package/dist/functions/conllu/ConlluUtils.js

@@ -0,0 +1,271 @@
+import { saveAs } from 'file-saver';
+const convertStructToConllu = (struct) => {
+    return {
+        uid: struct.uid,
+        page: struct.page,
+        tokens: struct.conllu || [],
+        attributes: struct.attributes || {},
+    };
+};
+const getAsText = (conllu) => {
+    let value = '';
+    conllu.tokens.forEach((token) => {
+        value += `${token.form} `;
+    });
+    return value.trim();
+};
+const convertToCytoscape = (conllu) => {
+    const tokens = conllu.tokens.filter((t) => t.id?.indexOf('-') === -1);
+    if (tokens.length === 0)
+        return { nodes: [], edges: [] };
+    const nodes = [];
+    const edges = [];
+    const uids = [uuid()];
+    nodes.push({
+        data: {
+            id: uids[0],
+            root: true,
+            token: {
+                id: 0,
+                form: 'root',
+            },
+        },
+    });
+    for (const token of tokens) {
+        const thisUid = uuid();
+        uids.push(thisUid);
+        nodes.push({
+            data: {
+                id: thisUid,
+                token,
+            },
+        });
+    }
+    for (const token of tokens) {
+        if (token.head !== null && token.deprel) {
+            edges.push({
+                data: {
+                    id: uuid(),
+                    label: token.deprel,
+                    target: uids[parseInt(token.id)],
+                    source: uids[parseInt(token.head)],
+                },
+            });
+        }
+    }
+    return { nodes, edges };
+};
+const isNotEmptyConllu = (conllu) => {
+    return conllu && conllu.tokens.length > 0;
+};
+const convertToSentence = (conllText) => {
+    const lines = conllText.trim().split('\n');
+    const headerInfo = {};
+    const tokens = [];
+    for (const line of lines) {
+        if (line.startsWith('#')) {
+            const [key, value] = line.split('=');
+            if (value)
+                headerInfo[key.slice(2).trim()] = value.trim();
+            else
+                headerInfo[key.slice(2).trim()] = '';
+        }
+        else {
+            const fields = line.split('\t');
+            // check if id has '-', if positive this is a splitter
+            if (fields[0].indexOf('-') != -1)
+                continue;
+            const token = {
+                id: fields[0],
+                form: fields[1],
+                lemma: fields[2],
+                upos: fields[3],
+                xpos: fields[4] !== '_' ? fields[4] : '',
+                feats: fields[5] !== '_' ? fields[5] : '',
+                head: fields[6] ? fields[6] : '',
+                deprel: fields[7] ? fields[7] : '',
+                deps: fields[8] !== '_' ? fields[8] : '',
+                misc: fields[9] !== '_' ? fields[9] : '',
+            };
+            tokens.push(token);
+        }
+    }
+    const conllu = {
+        uid: uuid(),
+        page: '',
+        attributes: headerInfo || {},
+        tokens: tokens,
+    };
+    return conllu;
+};
+const convertToConllu = (conllu) => {
+    if (!isNotEmptyConllu(conllu))
+        return '';
+    const attributesLines = Object.entries(conllu.attributes)
+        .map(([key, value]) => `# ${key} = ${value}`)
+        .join('\n');
+    const tokenLines = conllu.tokens
+        .map((token) => [
+        token.id,
+        token.form,
+        token.lemma,
+        token.upos,
+        token.xpos,
+        token.feats,
+        token.head,
+        token.deprel,
+        token.deps === '' ? '_' : token.deps,
+        token.misc,
+    ].join('\t'))
+        .join('\n');
+    return [attributesLines, tokenLines].join('\n');
+};
+/**
+ * Deletes a token from the Conllu structure and updates all related references.
+ * - Updates token IDs to maintain sequential order (1, 2, 3, ...)
+ * - Updates HEAD references: if HEAD points to deleted token, points to previous token (or first if deleted was first)
+ * - Decrements HEAD references that point to tokens after the deleted one
+ */
+const deleteToken = (conllu, tokenIndex) => {
+    if (tokenIndex < 0 || tokenIndex >= conllu.tokens.length) {
+        return conllu;
+    }
+    // Get the ID of the token being deleted (as number for comparison)
+    const deletedToken = conllu.tokens[tokenIndex];
+    const deletedTokenId = deletedToken.id;
+    const deletedTokenIdNum = Number(deletedTokenId);
+    // Calculate the new ID of the token before the deleted one
+    // After deletion and renumbering, if we delete at index i:
+    // - Token at index i-1 will have new ID = i (which is String(i))
+    // - If deleting first token (index 0), the new first token will have ID "1"
+    const previousTokenNewId = tokenIndex > 0 ? String(tokenIndex) : conllu.tokens.length > 1 ? '1' : '0';
+    // Remove the token at the specified index
+    const updatedTokens = conllu.tokens.filter((_, index) => index !== tokenIndex);
+    // Update IDs to be sequential (1, 2, 3, ...)
+    const tokensWithUpdatedIds = updatedTokens.map((token, index) => ({
+        ...token,
+        id: String(index + 1),
+    }));
+    // Update HEAD references based on the old IDs before deletion
+    const tokensWithUpdatedHeads = tokensWithUpdatedIds.map((token, newIndex) => {
+        // Get the original token (before ID update) to check its original HEAD
+        const originalToken = updatedTokens[newIndex];
+        // Skip if HEAD is empty, null, or '_'
+        if (!originalToken.head ||
+            originalToken.head === '_' ||
+            originalToken.head === '') {
+            return token;
+        }
+        const headIdNum = Number(originalToken.head);
+        // If HEAD points to the deleted token, point to the previous token (or first if deleted was first)
+        if (originalToken.head === deletedTokenId) {
+            return {
+                ...token,
+                head: previousTokenNewId,
+            };
+        }
+        // If HEAD points to a token after the deleted one, decrement it by 1
+        if (headIdNum > deletedTokenIdNum) {
+            return {
+                ...token,
+                head: String(headIdNum - 1),
+            };
+        }
+        // If HEAD points to a token before the deleted one, no change needed
+        // But we need to ensure the HEAD value is still valid after renumbering
+        // Since tokens before the deleted one keep their relative positions, their IDs don't change
+        // So we can keep the original HEAD value
+        return token;
+    });
+    return {
+        ...conllu,
+        tokens: tokensWithUpdatedHeads,
+    };
+};
+const uuid = () => 'xxxxxxxx'.replace(/[xy]/g, (c) => {
+    /* eslint-disable */
+    const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+    /* eslint-enable */
+    return v.toString(16);
+});
+const extractConlluTokens = (conllText) => {
+    const lines = conllText.trim().split('\n');
+    const headerInfo = {};
+    const tokens = [];
+    for (const line of lines) {
+        if (line.startsWith('#')) {
+            const [key, value] = line.split('=');
+            if (value)
+                headerInfo[key.slice(2).trim()] = value.trim();
+            else
+                headerInfo[key.slice(2).trim()] = '';
+        }
+        else {
+            const fields = line.split('\t');
+            // check if id has '-', if positive this is a splitter
+            if (fields[0].indexOf('-') != -1)
+                continue;
+            const token = {
+                id: fields[0],
+                form: fields[1],
+                lemma: fields[2],
+                upos: fields[3],
+                xpos: fields[4] !== '_' ? fields[4] : '',
+                feats: fields[5] !== '_' ? fields[5] : '',
+                head: fields[6] ? fields[6] : '',
+                deprel: fields[7] ? fields[7] : '',
+                deps: fields[8] !== '_' ? fields[8] : '',
+                misc: fields[9] !== '_' ? fields[9] : '',
+            };
+            tokens.push(token);
+        }
+    }
+    return tokens;
+};
+const getConlluTranslationFromStruct = (struct, lang) => {
+    return struct?.attributes?.[lang] || '';
+};
+const generateImageFromSVG = (svgElement) => {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    if (!context) {
+        throw new Error('Unable to get canvas context');
+    }
+    const { width, height } = svgElement.getBBox();
+    canvas.width = width;
+    canvas.height = height;
+    // Convert SVG element to data URL
+    const svgData = new XMLSerializer().serializeToString(svgElement);
+    const svgBlob = new Blob([svgData], {
+        type: 'image/svg+xml;charset=utf-8',
+    });
+    const url = URL.createObjectURL(svgBlob);
+    const img = new Image();
+    img.crossOrigin = 'anonymous'; // handle cross-origin issues
+    img.onload = async () => {
+        context.fillStyle = 'white';
+        context.fillRect(0, 0, width, height);
+        context.drawImage(img, 0, 0, width, height);
+        URL.revokeObjectURL(url);
+        // Convert canvas to JPEG blob
+        canvas.toBlob((blob) => {
+            if (blob === null)
+                return;
+            saveAs(blob, 'conllu.jpg');
+        }, 'image/jpeg', 1.0);
+    };
+    img.src = url;
+};
+const ConlluUtils = {
+    convertToSentence,
+    convertToConllu,
+    convertToCytoscape,
+    getAsText,
+    convertStructToConllu,
+    extractConlluTokens,
+    isNotEmptyConllu,
+    deleteToken,
+    getConlluTranslationFromStruct,
+    generateImageFromSVG,
+};
+export default ConlluUtils;

package/dist/functions/index.d.ts

@@ -9,6 +9,7 @@ export { EDITION_TOOLS, default as ToolsUtils, type PlatformTools, } from './Too
 export type { OpenDocumentParams, RedirectPageParams } from './ToolsUtils';
 export { default as UsabilityUtils } from './UsabilityUtils';
 export { conlluViewerConfigurations } from './conllu/ConlluViewerConstants';
+export { default as ConlluUtils } from './conllu/ConlluUtils';
 export { default as ConlluViewerConverter, calculateConlluTextWidth, throwConlluError, } from './conllu/ConlluViewerConverter';
 export type { ConlluViewerAnchor, ConlluViewerDependency, ConlluViewerGraph, ConlluViewerItem, ConlluViewerMulti, } from './conllu/ConlluViewerGraph';
 export { normalizeCorpusFromApi } from './normalizeCorpusFromApi';

package/dist/functions/index.js

@@ -8,5 +8,6 @@ export { default as SentenceUtils } from './SentenceUtils';
 export { EDITION_TOOLS, default as ToolsUtils, } from './ToolsUtils';
 export { default as UsabilityUtils } from './UsabilityUtils';
 export { conlluViewerConfigurations } from './conllu/ConlluViewerConstants';
+export { default as ConlluUtils } from './conllu/ConlluUtils';
 export { default as ConlluViewerConverter, calculateConlluTextWidth, throwConlluError, } from './conllu/ConlluViewerConverter';
 export { normalizeCorpusFromApi } from './normalizeCorpusFromApi';

package/package.json

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