tycho-components 0.1.0-SNAPSHOT-7 → 0.2.0-SNAPSHOT

package/dist/TreeView/cytoscape/CytoscapeTreeConverter.js

@@ -0,0 +1,331 @@
+import CytoscapePositionCalculator from './CytoscapePositionCalculator';
+import TreeLayout from './TreeLayout';
+class CytoscapeTreeConverter {
+    constructor() {
+        this.ID_SPLITTER = '|';
+        this.extraInfo = false;
+    }
+    execute(struct, extraInfo) {
+        if (!this.validate(struct))
+            return undefined;
+        const tree = this.initTree(struct);
+        this.extraInfo = extraInfo;
+        this.inflate(tree, struct);
+        this.calculatePositions(tree);
+        return {
+            nodes: tree.nodes.map((n) => ({
+                data: n.data,
+                position: n.position,
+                id: n.id,
+            })),
+            edges: tree.edges,
+            root: {
+                data: tree.root.data,
+                position: tree.root.position,
+                id: tree.root.id,
+            },
+        };
+    }
+    getLabelLeaf(token) {
+        if (this.extraInfo && token.attributes) {
+            const attrLines = Object.values(token.attributes)
+                .map((v) => v)
+                .join('\n');
+            return `${token.v}\n${attrLines}`;
+        }
+        return token.v;
+    }
+    validate(struct) {
+        if (!struct.chunks || struct.chunks.length === 0)
+            return false;
+        return true;
+    }
+    calculatePositions(cytoscape) {
+        const converter = new CytoscapePositionCalculator();
+        const positions = converter.calculatePositions(cytoscape);
+        for (const node of cytoscape.nodes) {
+            const rect = positions.get(node.id);
+            if (!rect)
+                continue;
+            node.position = {
+                x: rect.x,
+                y: rect.y,
+            };
+        }
+        try {
+            this.checkLastTokenPosition(cytoscape.nodes);
+        }
+        catch (e) {
+            // do nothing
+        }
+    }
+    checkLastTokenPosition(nodes) {
+        const last = nodes[nodes.length - 1];
+        const penult = nodes[nodes.length - 2];
+        const antepenult = nodes[nodes.length - 3];
+        if (last.position?.x < antepenult.position?.x) {
+            last.position = {
+                y: last.position?.y,
+                x: antepenult.position?.x + TreeLayout.MIN_NODE_WIDTH,
+            };
+            penult.position = {
+                y: penult.position?.y,
+                x: antepenult.position?.x + TreeLayout.MIN_NODE_WIDTH,
+            };
+        }
+    }
+    inflate(tree, struct) {
+        const chunks = struct.chunks.filter((c) => c.l !== 0);
+        for (const chunk of chunks) {
+            this.convertChunk(tree, struct, chunk);
+            this.removeTemporaryEdges(tree, struct, chunk);
+        }
+        struct.tokens
+            .filter((t) => t.ec)
+            .forEach((t) => {
+            const associated = struct.chunks.find((c) => this.isEmptyCategoryInChunk(c, t));
+            if (associated) {
+                this.convertEmptyCategory(tree, associated, t);
+            }
+        });
+    }
+    isEmptyCategoryInChunk(chunk, token) {
+        if (chunk.l !== token.l)
+            return false;
+        if (token.p >= chunk.i && token.p <= chunk.f)
+            return true;
+        return false;
+    }
+    convertEmptyCategory(tree, chunk, token) {
+        const id = this.generateLeafId(token);
+        const node = {
+            id,
+            data: {
+                id,
+                empty: true,
+                leaf: true,
+                label: this.getLabelValue(token.v, token.coidx),
+                token,
+            },
+        };
+        tree.nodes.push(node);
+        const source = this.generateChunkId(chunk);
+        // adds empty attribute to the chunk
+        const nodeChunk = tree.nodes.find((n) => n.id === source);
+        if (nodeChunk)
+            nodeChunk.data.chunk.empty = true;
+        tree.edges.push({
+            data: {
+                id: this.uuid(),
+                source: source,
+                target: node.id,
+            },
+        });
+    }
+    convertChunk(tree, struct, chunk) {
+        const nodeId = this.generateChunkId(chunk);
+        tree.nodes.push({
+            id: nodeId,
+            data: {
+                id: nodeId,
+                label: this.getLabelValue(chunk.t, chunk.coidx),
+                chunk: { ...chunk },
+            },
+        });
+        const parent = this.findParent(struct, chunk);
+        if (!parent)
+            return;
+        const parentId = this.generateChunkId(parent);
+        tree.edges.push({
+            data: {
+                id: this.uuid(),
+                source: parentId,
+                target: nodeId,
+            },
+        });
+        const tokens = this.getTokens(struct, chunk);
+        for (const token of tokens) {
+            if (token.ec)
+                continue;
+            tree.edges.push({
+                data: {
+                    id: this.uuid(),
+                    source: nodeId,
+                    target: this.generateTokenId(token),
+                },
+            });
+        }
+    }
+    removeTemporaryEdges(tree, struct, chunk) {
+        let levelCount = 1;
+        let leveledChunks = this.getChunksByLevel(struct, chunk, levelCount);
+        while (leveledChunks.length > 0) {
+            for (const upperChunk of leveledChunks) {
+                const upperChunkId = this.generateChunkId(upperChunk);
+                for (const token of this.getTokens(struct, chunk)) {
+                    const tokenId = this.generateTokenId(token);
+                    tree.edges = [
+                        ...tree.edges.filter((e) => !(e.data.source === upperChunkId && e.data.target === tokenId)),
+                    ];
+                }
+            }
+            leveledChunks = this.getChunksByLevel(struct, chunk, levelCount);
+            levelCount++;
+        }
+    }
+    generateChunkId(chunk) {
+        return `${chunk.i}${this.ID_SPLITTER}${chunk.f}${this.ID_SPLITTER}${chunk.l}${this.ID_SPLITTER}${chunk.t}`;
+    }
+    generateTokenId(token) {
+        const sb = [];
+        if (token.p === null)
+            return '0';
+        sb.push(`${token.p}`);
+        if (token.idx) {
+            sb.push('-');
+            sb.push(`${token.idx}`);
+        }
+        if (token.t) {
+            sb.push('+');
+            sb.push(token.t);
+        }
+        return sb.join('');
+    }
+    generateLeafId(token) {
+        if (token.p === null)
+            return '0';
+        return `${token.p}`;
+    }
+    findParent(struct, chunk) {
+        const chunks = this.getChunksByLevel(struct, chunk, 1);
+        if (chunks.length === 0)
+            return null;
+        for (const parent of chunks) {
+            const tf = chunk.f;
+            const ti = chunk.i;
+            const ptf = parent.f;
+            const pti = parent.i;
+            if (tf <= ptf && ti >= pti)
+                return parent;
+        }
+        return null;
+    }
+    initTree(struct) {
+        this.sortChunks(struct);
+        const chunkRoot = struct.chunks.length === 1
+            ? struct.chunks[0]
+            : struct.chunks.find((c) => c.l === 0);
+        if (!chunkRoot)
+            throw new Error('struct.root.notfound');
+        chunkRoot.l = 0;
+        const rootId = this.generateChunkId(chunkRoot);
+        const root = {
+            id: rootId,
+            data: {
+                id: rootId,
+                label: this.getLabelValue(chunkRoot.t, chunkRoot.coidx),
+                chunk: chunkRoot,
+            },
+        };
+        const tree = {
+            nodes: [root],
+            edges: [],
+            root,
+        };
+        for (let i = chunkRoot.i; i < chunkRoot.f + 1; i++) {
+            const token = struct.tokens.find((t) => t.p === i);
+            if (!token)
+                continue;
+            this.convertToken(tree, token);
+        }
+        return tree;
+    }
+    sortChunks(struct) {
+        struct.chunks.sort((chunk1, chunk2) => {
+            if (chunk1.l !== chunk2.l) {
+                return chunk1.l - chunk2.l;
+            }
+            if (chunk1.i !== chunk2.i) {
+                return chunk1.i - chunk2.i;
+            }
+            return chunk1.f - chunk2.f;
+        });
+    }
+    convertToken(tree, token) {
+        if (token.ec)
+            return;
+        let id = this.generateTokenId(token);
+        const tag = {
+            id,
+            data: {
+                id,
+                label: this.getLabelValue(token.t, token.coidx),
+                token: JSON.parse(JSON.stringify(token)),
+            },
+        };
+        tree.nodes.push(tag);
+        tree.edges.push({
+            data: {
+                id: this.uuid(),
+                source: tree.root.id,
+                target: tag.id,
+            },
+        });
+        id = this.generateLeafId(token);
+        const word = {
+            id,
+            data: {
+                id,
+                leaf: true,
+                label: this.getLabelLeaf(token),
+                token: JSON.parse(JSON.stringify(token)),
+            },
+        };
+        tree.nodes.push(word);
+        tree.edges.push({
+            data: {
+                id: this.uuid(),
+                source: tag.id,
+                target: word.id,
+            },
+        });
+    }
+    getTokens(struct, chunk) {
+        const ti = chunk.i;
+        const tf = chunk.f;
+        if (ti === null || tf === null || tf < ti)
+            return [];
+        const tokens = this.sortTokens(struct.tokens);
+        return tokens.slice(ti - 1, tf);
+    }
+    getLabelValue(value, coidx) {
+        let idxLabel = '';
+        if (coidx) {
+            for (const idx of coidx) {
+                idxLabel += `-${idx.toString()}`;
+            }
+        }
+        return value ?? '' + idxLabel;
+    }
+    getChunksByLevel(struct, chunk, level) {
+        return struct.chunks.filter((c) => c.l === chunk.l - level);
+    }
+    sortTokens(tokens) {
+        return tokens
+            .slice() // Create a shallow copy to avoid modifying the original array
+            .sort((o1, o2) => {
+            if (o1.p === null || o2.p === null)
+                return -1;
+            return o1.p - o2.p;
+        });
+    }
+    uuid() {
+        return '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);
+        });
+    }
+}
+export default CytoscapeTreeConverter;

package/dist/TreeView/cytoscape/NodeBounds.d.ts

@@ -0,0 +1,7 @@
+type NodeBounds = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export default NodeBounds;

package/dist/TreeView/cytoscape/NodeBounds.js

@@ -0,0 +1 @@
+export {};

package/dist/TreeView/cytoscape/NodeCalculation.d.ts

@@ -0,0 +1,14 @@
+import { EdgeDefinition, NodeDataDefinition, Position } from 'cytoscape';
+export type CytoscapeTreeCalculation = {
+    nodes: NodeCalculation[];
+    edges: EdgeDefinition[];
+    root: NodeCalculation;
+};
+type NodeCalculation = {
+    id: string;
+    data: NodeDataDefinition;
+    position?: Position;
+    parent?: NodeCalculation;
+    children?: NodeCalculation[];
+};
+export default NodeCalculation;

package/dist/TreeView/cytoscape/NodeCalculation.js

@@ -0,0 +1 @@
+export {};

package/dist/TreeView/cytoscape/NormalizedPosition.d.ts

@@ -0,0 +1,8 @@
+declare class NormalizedPosition {
+    private xRelativeToRoot;
+    private yRelativeToRoot;
+    constructor(xRelativeToRoot: number, yRelativeToRoot: number);
+    getX(boundsLeft: number): number;
+    getY(boundsTop: number): number;
+}
+export default NormalizedPosition;

package/dist/TreeView/cytoscape/NormalizedPosition.js

@@ -0,0 +1,13 @@
+class NormalizedPosition {
+    constructor(xRelativeToRoot, yRelativeToRoot) {
+        this.xRelativeToRoot = xRelativeToRoot;
+        this.yRelativeToRoot = yRelativeToRoot;
+    }
+    getX(boundsLeft) {
+        return this.xRelativeToRoot - boundsLeft;
+    }
+    getY(boundsTop) {
+        return this.yRelativeToRoot - boundsTop;
+    }
+}
+export default NormalizedPosition;

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

@@ -0,0 +1,6 @@
+import { Core } from 'cytoscape';
+import { CytoscapeTree } from '../../configs/types/Tree';
+declare const SyntreesCytoscape: {
+    init: (selector: string, tree: CytoscapeTree, onReady?: (cy: Core) => void) => Core;
+};
+export default SyntreesCytoscape;

package/dist/TreeView/cytoscape/SyntreesCytoscape.js

@@ -0,0 +1,49 @@
+import cytoscape from 'cytoscape';
+import stylesheet from './CytoscapeStylesheet';
+const init = (selector, tree, onReady) => {
+    destroy(selector);
+    const cy = cytoscape({
+        container: document.getElementById(selector),
+        layout: { name: 'preset' },
+        elements: { nodes: tree.nodes || [], edges: tree.edges || [] },
+        style: stylesheet,
+        zoom: 2,
+        pan: tree.pan || { x: 100, y: 100 },
+        minZoom: 1e-50,
+        maxZoom: 1e50,
+        zoomingEnabled: true,
+        userZoomingEnabled: true,
+        userPanningEnabled: true,
+        boxSelectionEnabled: true,
+        selectionType: 'single',
+        touchTapThreshold: 8,
+        desktopTapThreshold: 4,
+        autolock: false,
+        autoungrabify: true,
+        autounselectify: false,
+        headless: false,
+        styleEnabled: true,
+        hideEdgesOnViewport: false,
+        hideLabelsOnViewport: false,
+        textureOnViewport: false,
+        motionBlur: false,
+        motionBlurOpacity: 0.2,
+        wheelSensitivity: 0.3,
+        pixelRatio: 1,
+    });
+    cy.ready(() => {
+        cy.fit();
+        cy.center();
+        onReady && onReady(cy);
+    });
+    return cy;
+};
+const destroy = (selector) => {
+    const el = document.getElementById(selector);
+    if (el)
+        el.innerHTML = '';
+};
+const SyntreesCytoscape = {
+    init,
+};
+export default SyntreesCytoscape;

package/dist/TreeView/cytoscape/TreeLayout.d.ts

@@ -0,0 +1,64 @@
+import NodeBounds from './NodeBounds';
+import NodeCalculation from './NodeCalculation';
+declare class TreeLayout {
+    static MIN_NODE_WIDTH: number;
+    static MIN_NODE_HEIGHT: number;
+    private configuration;
+    private boundsLeft;
+    private boundsTop;
+    private boundsRight;
+    private boundsBottom;
+    private sizeOfLevel;
+    private nodeBounds;
+    private mod;
+    private thread;
+    private prelim;
+    private change;
+    private shift;
+    private ancestor;
+    private number;
+    private positions;
+    constructor(root: NodeCalculation);
+    getNodeBounds(): Map<string, NodeBounds>;
+    private getSizeOfLevel;
+    private getMod;
+    private setMod;
+    private getThread;
+    private setThread;
+    private getAncestor;
+    private setAncestor;
+    private getPrelim;
+    private setPrelim;
+    private getChange;
+    private setChange;
+    private getShift;
+    private setShift;
+    private getDistance;
+    private nextLeft;
+    private nextRight;
+    private getNumber;
+    private getChildren;
+    private detectAncestor;
+    private moveSubtree;
+    private apportion;
+    private executeShifts;
+    private cloneMap;
+    private firstWalk;
+    private secondWalk;
+    private getNodeHeight;
+    private getNodeWidth;
+    private getWidthOrHeightOfNode;
+    private getNodeThickness;
+    private getNodeSize;
+    private isLevelChangeInYAxis;
+    private getLevelChangeSign;
+    private updateBounds;
+    private calcSizeOfLevels;
+    private getLevelCount;
+    private isLeaf;
+    private isChildOfParent;
+    private getChildrenReverse;
+    private getFirstChild;
+    private getLastChild;
+}
+export default TreeLayout;