tycho-components 0.1.0-SNAPSHOT-8 → 0.2.0-SNAPSHOT

package/dist/TreeView/cytoscape/TreeLayout.js

@@ -0,0 +1,353 @@
+import { AlignmentInLevel, Configuration, Location } from './Configuration';
+import NormalizedPosition from './NormalizedPosition';
+class TreeLayout {
+    constructor(root) {
+        this.boundsLeft = Number.MAX_VALUE;
+        this.boundsTop = Number.MAX_VALUE;
+        this.boundsRight = Number.MIN_VALUE;
+        this.boundsBottom = Number.MIN_VALUE;
+        this.sizeOfLevel = [];
+        this.nodeBounds = new Map();
+        this.mod = new Map();
+        this.thread = new Map();
+        this.prelim = new Map();
+        this.change = new Map();
+        this.shift = new Map();
+        this.ancestor = new Map();
+        this.number = new Map();
+        this.positions = new Map();
+        this.configuration = new Configuration();
+        const r = root;
+        this.firstWalk(r, null);
+        this.calcSizeOfLevels(r, 0);
+        this.secondWalk(r, -this.getPrelim(r), 0, 0);
+    }
+    getNodeBounds() {
+        this.nodeBounds = new Map();
+        for (const [node, pos] of this.positions.entries()) {
+            const w = this.getNodeWidth();
+            const h = this.getNodeHeight();
+            const x = pos.getX(this.boundsLeft) - w / 2;
+            const y = pos.getY(this.boundsTop) - h / 2;
+            this.nodeBounds.set(node, { x, y, w, h });
+        }
+        return this.nodeBounds;
+    }
+    getSizeOfLevel(level) {
+        if (level < 0 || level >= this.getLevelCount()) {
+            throw new Error('level must be >= 0 and < levelCount');
+        }
+        return this.sizeOfLevel[level];
+    }
+    getMod(node) {
+        if (!node)
+            return 0;
+        return this.mod.get(node.id) || 0;
+    }
+    setMod(node, d) {
+        if (!node)
+            return;
+        this.mod.set(node.id, d);
+    }
+    getThread(node) {
+        const n = this.thread.get(node.id);
+        return n !== undefined ? n : null;
+    }
+    setThread(node, thread) {
+        if (!node)
+            return;
+        this.thread.set(node.id, thread);
+    }
+    getAncestor(node) {
+        return this.ancestor.get(node.id) || node;
+    }
+    setAncestor(node, ancestor) {
+        if (!node)
+            return;
+        this.ancestor.set(node.id, ancestor);
+    }
+    getPrelim(node) {
+        if (!node)
+            return 0;
+        return this.prelim.get(node.id) || 0;
+    }
+    setPrelim(node, d) {
+        this.prelim.set(node.id, d);
+    }
+    getChange(node) {
+        return this.change.get(node.id) || 0;
+    }
+    setChange(node, d) {
+        this.change.set(node.id, d);
+    }
+    getShift(node) {
+        return this.shift.get(node.id) || 0;
+    }
+    setShift(node, d) {
+        this.shift.set(node.id, d);
+    }
+    getDistance(v, w) {
+        const sizeOfNodes = this.getNodeSize(v) + this.getNodeSize(w);
+        const distance = sizeOfNodes / 2 + this.configuration.gapBetweenNodes;
+        return distance;
+    }
+    nextLeft(v) {
+        if (!v)
+            return null;
+        return this.isLeaf(v) ? this.getThread(v) : this.getFirstChild(v);
+    }
+    nextRight(v) {
+        if (!v)
+            return null;
+        return this.isLeaf(v) ? this.getThread(v) : this.getLastChild(v);
+    }
+    getNumber(node, parentNode) {
+        const n = this.number.get(node.id);
+        if (!n) {
+            let i = 1;
+            for (const child of this.getChildren(parentNode)) {
+                this.number.set(child.id, i);
+                i += 1;
+            }
+            return this.number.get(node.id) || 0;
+        }
+        return n;
+    }
+    getChildren(node) {
+        return node.children || [];
+    }
+    detectAncestor(vIMinus, parentOfV, defaultAncestor) {
+        const ancestor = this.getAncestor(vIMinus);
+        return this.isChildOfParent(ancestor, parentOfV)
+            ? ancestor
+            : defaultAncestor;
+    }
+    moveSubtree(wMinus, wPlus, parent, shift) {
+        const subtrees = this.getNumber(wPlus, parent) - this.getNumber(wMinus, parent);
+        this.setChange(wPlus, this.getChange(wPlus) - shift / subtrees);
+        this.setShift(wPlus, this.getShift(wPlus) + shift);
+        this.setChange(wMinus, this.getChange(wMinus) + shift / subtrees);
+        this.setPrelim(wPlus, this.getPrelim(wPlus) + shift);
+        this.setMod(wPlus, this.getMod(wPlus) + shift);
+    }
+    apportion(v, defaultAncestor, leftSibling, parentOfV) {
+        const w = leftSibling;
+        if (w === null) {
+            return defaultAncestor;
+        }
+        let vOPlus = v;
+        let vIPlus = v;
+        let vIMinus = w;
+        let vOMinus = this.getFirstChild(parentOfV);
+        let sIPlus = this.getMod(vIPlus);
+        let sOPlus = this.getMod(vOPlus);
+        let sIMinus = this.getMod(vIMinus);
+        let sOMinus = this.getMod(vOMinus);
+        let nextRightVIMinus = this.nextRight(vIMinus);
+        let nextLeftVIPlus = this.nextLeft(vIPlus);
+        while (nextRightVIMinus !== null && nextLeftVIPlus !== null) {
+            vIMinus = nextRightVIMinus;
+            vIPlus = nextLeftVIPlus;
+            vOMinus = this.nextLeft(vOMinus);
+            vOPlus = this.nextRight(vOPlus);
+            this.setAncestor(vOPlus, v);
+            const shift = this.getPrelim(vIMinus) +
+                sIMinus -
+                (this.getPrelim(vIPlus) + sIPlus) +
+                this.getDistance(vIMinus, vIPlus);
+            if (shift > 0) {
+                this.moveSubtree(this.detectAncestor(vIMinus, parentOfV, defaultAncestor), v, parentOfV, shift);
+                sIPlus += shift;
+                sOPlus += shift;
+            }
+            sIMinus += this.getMod(vIMinus);
+            sIPlus += this.getMod(vIPlus);
+            sOMinus += this.getMod(vOMinus);
+            sOPlus += this.getMod(vOPlus);
+            nextRightVIMinus = this.nextRight(vIMinus);
+            nextLeftVIPlus = this.nextLeft(vIPlus);
+        }
+        if (nextRightVIMinus !== null && this.nextRight(vOPlus) === null) {
+            this.setThread(vOPlus, nextRightVIMinus);
+            this.setMod(vOPlus, this.getMod(vOPlus) + sIMinus - sOPlus);
+        }
+        if (nextLeftVIPlus !== null && this.nextLeft(vOMinus) === null) {
+            this.setThread(vOMinus, nextLeftVIPlus);
+            this.setMod(vOMinus, this.getMod(vOMinus) + sIPlus - sOMinus);
+            defaultAncestor = v;
+        }
+        return defaultAncestor;
+    }
+    executeShifts(v) {
+        let shift = 0;
+        let change = 0;
+        for (const w of this.getChildrenReverse(v)) {
+            change += this.getChange(w);
+            this.setPrelim(w, this.getPrelim(w) + shift);
+            this.setMod(w, this.getMod(w) + shift);
+            shift += this.getShift(w) + change;
+        }
+    }
+    cloneMap(originalMap) {
+        const clonedMap = new Map();
+        // Add all entries from the original map to the cloned map
+        for (const [key, value] of originalMap.entries()) {
+            clonedMap.set(key, value);
+        }
+        return clonedMap;
+    }
+    firstWalk(v, leftSibling) {
+        if (this.isLeaf(v)) {
+            const w = leftSibling;
+            if (w !== null) {
+                this.setPrelim(v, this.getPrelim(w) + this.getDistance(v, w));
+            }
+        }
+        else {
+            let defaultAncestor = this.getFirstChild(v);
+            let previousChild = null;
+            if (!defaultAncestor)
+                throw new Error('chunk.children.empty');
+            for (const w of this.getChildren(v)) {
+                this.firstWalk(w, previousChild);
+                defaultAncestor = this.apportion(w, defaultAncestor, previousChild, v);
+                previousChild = w;
+            }
+            this.executeShifts(v);
+            const midpoint = (this.getPrelim(this.getFirstChild(v)) +
+                this.getPrelim(this.getLastChild(v))) /
+                2.0;
+            const w = leftSibling;
+            if (w !== null) {
+                this.setPrelim(v, this.getPrelim(w) + this.getDistance(v, w));
+                this.setMod(v, this.getPrelim(v) - midpoint);
+            }
+            else {
+                this.setPrelim(v, midpoint);
+            }
+        }
+    }
+    secondWalk(v, m, level, levelStart) {
+        const levelChangeSign = this.getLevelChangeSign();
+        const levelChangeOnYAxis = this.isLevelChangeInYAxis();
+        const levelSize = this.getSizeOfLevel(level);
+        let x = this.getPrelim(v) + m;
+        let y;
+        const alignment = this.configuration.alignmentInLevel;
+        if (alignment === AlignmentInLevel.Center) {
+            y = levelStart + levelChangeSign * (levelSize / 2);
+        }
+        else if (alignment === AlignmentInLevel.TowardsRoot) {
+            y = levelStart + levelChangeSign * (this.getNodeThickness(v) / 2);
+        }
+        else {
+            y =
+                levelStart +
+                    levelSize -
+                    levelChangeSign * (this.getNodeThickness(v) / 2);
+        }
+        if (!levelChangeOnYAxis) {
+            const t = x;
+            x = y;
+            y = t;
+        }
+        this.positions.set(v.id, new NormalizedPosition(x, y));
+        this.updateBounds(x, y);
+        if (!this.isLeaf(v)) {
+            const nextLevelStart = levelStart +
+                (levelSize + this.configuration.gapBetweenLevels) * levelChangeSign;
+            for (const w of this.getChildren(v)) {
+                this.secondWalk(w, m + this.getMod(v), level + 1, nextLevelStart);
+            }
+        }
+    }
+    getNodeHeight() {
+        return TreeLayout.MIN_NODE_HEIGHT;
+    }
+    getNodeWidth() {
+        return TreeLayout.MIN_NODE_WIDTH;
+    }
+    getWidthOrHeightOfNode(returnWidth) {
+        return returnWidth ? this.getNodeWidth() : this.getNodeHeight();
+    }
+    getNodeThickness(treeNode) {
+        return this.getWidthOrHeightOfNode(!this.isLevelChangeInYAxis());
+    }
+    getNodeSize(treeNode) {
+        return this.getWidthOrHeightOfNode(this.isLevelChangeInYAxis());
+    }
+    isLevelChangeInYAxis() {
+        const rootLocation = this.configuration.location;
+        return rootLocation === Location.Top || rootLocation === Location.Bottom;
+    }
+    getLevelChangeSign() {
+        const rootLocation = this.configuration.location;
+        return rootLocation === Location.Bottom || rootLocation === Location.Right
+            ? -1
+            : 1;
+    }
+    updateBounds(centerX, centerY) {
+        const width = this.getNodeWidth();
+        const height = this.getNodeHeight();
+        const left = centerX - width / 2;
+        const right = centerX + width / 2;
+        const top = centerY - height / 2;
+        const bottom = centerY + height / 2;
+        if (this.boundsLeft > left) {
+            this.boundsLeft = left;
+        }
+        if (this.boundsRight < right) {
+            this.boundsRight = right;
+        }
+        if (this.boundsTop > top) {
+            this.boundsTop = top;
+        }
+        if (this.boundsBottom < bottom) {
+            this.boundsBottom = bottom;
+        }
+    }
+    calcSizeOfLevels(node, level) {
+        let oldSize;
+        if (this.sizeOfLevel.length <= level) {
+            this.sizeOfLevel.push(0);
+            oldSize = 0;
+        }
+        else {
+            oldSize = this.sizeOfLevel[level];
+        }
+        const size = this.getNodeThickness(node);
+        if (oldSize < size) {
+            this.sizeOfLevel[level] = size;
+        }
+        if (!this.isLeaf(node)) {
+            for (const child of this.getChildren(node)) {
+                this.calcSizeOfLevels(child, level + 1);
+            }
+        }
+    }
+    getLevelCount() {
+        return this.sizeOfLevel.length;
+    }
+    isLeaf(node) {
+        return this.getChildren(node).length === 0;
+    }
+    isChildOfParent(node, parentNode) {
+        return node.parent === parentNode;
+    }
+    getChildrenReverse(node) {
+        const list = [...this.getChildren(node)];
+        list.reverse();
+        return list;
+    }
+    getFirstChild(parentNode) {
+        const list = this.getChildren(parentNode);
+        return list.length > 0 ? list[0] : null;
+    }
+    getLastChild(parentNode) {
+        const list = this.getChildren(parentNode);
+        return list.length > 0 ? list[list.length - 1] : null;
+    }
+}
+TreeLayout.MIN_NODE_WIDTH = 70;
+TreeLayout.MIN_NODE_HEIGHT = 50;
+export default TreeLayout;

package/dist/TreeView/index.d.ts

@@ -0,0 +1,2 @@
+import TreeView from './TreeView';
+export default TreeView;

package/dist/TreeView/index.js

@@ -0,0 +1,2 @@
+import TreeView from './TreeView';
+export default TreeView;

package/dist/TreeView/style.scss

@@ -0,0 +1,36 @@
+.tree-view-container {
+  position: relative;
+  padding-top: 8px;
+
+  .canvas-tree {
+    height: 80vh;
+    padding: 16px;
+    background-color: var(--color-surface);
+    border: var(--border-default);
+    border-radius: var(--border-radius-button);
+  }
+
+  .floating-button {
+    position: absolute;
+    top: 16px;
+    z-index: 1100;
+    background-color: transparent;
+    border: none;
+
+    svg {
+      width: 24px;
+      height: 24px;
+    }
+  }
+
+  .info {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    z-index: 1100;
+
+    .translation b {
+      margin-right: 4px;
+    }
+  }
+}

package/dist/TreeView/types/TreeViewExample.d.ts

@@ -0,0 +1,2 @@
+import { Struct } from '../../configs/types/Struct';
+export declare const structExample: Struct;

package/dist/TreeView/types/TreeViewExample.js

@@ -0,0 +1,261 @@
+export const structExample = {
+    uid: '13e0ee30-8f07-11e6-b457-90b11c409ded',
+    tokens: [
+        {
+            attributes: {
+                'gloss-br': 'agora',
+                gloss: 'now',
+            },
+            p: 1,
+            v: 'natigide',
+            t: 'ADV',
+            l: 1,
+        },
+        {
+            splits: [
+                {
+                    attributes: {
+                        'gloss-br': 'Ant',
+                        gloss: 'Ant',
+                    },
+                    v: 'n',
+                    t: 'Ant',
+                },
+                {
+                    attributes: {
+                        'gloss-br': 'história',
+                        gloss: 'history',
+                    },
+                    v: 'atema',
+                    t: 'n',
+                },
+                {
+                    attributes: {
+                        'gloss-br': 'de',
+                        gloss: 'of',
+                    },
+                    v: 'tigi',
+                    t: 'Apl',
+                },
+            ],
+            attributes: {
+                'gloss-br': 'história',
+            },
+            p: 2,
+            v: 'natematigi',
+            t: 'N$',
+            l: 2,
+        },
+        {
+            splits: [
+                {
+                    attributes: {
+                        'gloss-br': 'fem',
+                        gloss: 'fem',
+                    },
+                    v: 'a',
+                    t: 'Gnr',
+                },
+                {
+                    attributes: {
+                        'gloss-br': 'ausente',
+                        gloss: 'absent',
+                    },
+                    v: 'ca',
+                    t: 'Ncl',
+                },
+                {
+                    attributes: {
+                        'gloss-br': 'Hon',
+                        gloss: 'Hon',
+                    },
+                    v: 'wa',
+                    t: 'Hon',
+                },
+            ],
+            attributes: {
+                'gloss-br': 'uma',
+            },
+            p: 3,
+            v: 'acoa',
+            t: 'D',
+            l: 1,
+        },
+        {
+            splits: [
+                {
+                    attributes: {
+                        'gloss-br': 'mulher',
+                        gloss: 'woman',
+                    },
+                    v: 'iwalo',
+                    t: 'n',
+                },
+            ],
+            attributes: {
+                'gloss-br': 'mulher',
+            },
+            p: 4,
+            v: 'iwaalo',
+            t: 'N',
+            l: 1,
+        },
+        {
+            attributes: {
+                'gloss-br': 'que ',
+            },
+            p: 5,
+            v: 'ane',
+            t: 'WPRO',
+            l: 3,
+        },
+        {
+            p: 6,
+            v: '*T*',
+            l: 4,
+            ec: true,
+            coidx: [1],
+        },
+        {
+            splits: [
+                {
+                    v: 'di',
+                    t: 'Inv',
+                },
+                {
+                    v: 'n',
+                    t: 'Ref',
+                },
+                {
+                    attributes: {
+                        'gloss-br': 'virar',
+                        gloss: 'turn',
+                    },
+                    v: 'ana',
+                    t: 'v',
+                },
+                {
+                    attributes: {
+                        'gloss-br': 'para',
+                        gloss: 'into',
+                    },
+                    v: 'tigi',
+                    t: 'Apl',
+                },
+            ],
+            attributes: {
+                'gloss-br': 'virava',
+            },
+            p: 7,
+            v: 'dinanatigi',
+            t: 'VBAPL',
+            l: 3,
+        },
+        {
+            attributes: {
+                'gloss-br': 'que',
+            },
+            p: 8,
+            v: 'me',
+            t: 'C',
+            l: 4,
+        },
+        {
+            splits: [
+                {
+                    attributes: {
+                        'gloss-br': 'onça',
+                        gloss: 'jaguar',
+                    },
+                    v: 'nigediogo',
+                    t: 'n',
+                },
+            ],
+            attributes: {
+                'gloss-br': 'onça',
+            },
+            p: 9,
+            v: 'nigediogo',
+            t: 'N',
+            l: 6,
+        },
+        {
+            p: 10,
+            v: '.',
+            t: '.',
+            l: 0,
+        },
+    ],
+    chunks: [
+        {
+            i: 1,
+            f: 10,
+            t: 'IP-MAT',
+            l: 0,
+        },
+        {
+            i: 1,
+            f: 1,
+            t: 'ADVP',
+            l: 1,
+        },
+        {
+            i: 2,
+            f: 9,
+            t: 'NP',
+            l: 1,
+        },
+        {
+            i: 2,
+            f: 2,
+            t: 'NP',
+            l: 2,
+        },
+        {
+            i: 5,
+            f: 9,
+            t: 'CP-REL',
+            l: 2,
+        },
+        {
+            i: 5,
+            f: 5,
+            t: 'WNP',
+            l: 3,
+            coidx: [1],
+        },
+        {
+            i: 6,
+            f: 9,
+            t: 'IP-SUB',
+            l: 3,
+        },
+        {
+            i: 8,
+            f: 9,
+            t: 'CP-me',
+            l: 4,
+        },
+        {
+            i: 9,
+            f: 9,
+            t: 'IP-SUB',
+            l: 5,
+        },
+        {
+            i: 9,
+            f: 9,
+            t: 'NP',
+            l: 6,
+        },
+        {
+            i: 6,
+            f: 6,
+            t: 'NP-TRACE',
+            l: 4,
+        },
+    ],
+    corpus: 'C12',
+    document: 'D388',
+    page: 'P7029',
+};