tycho-components 0.25.12 → 0.26.1

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

@@ -13,11 +13,15 @@ export default class CytoscapeTreeConverter {
     private isEmptyCategoryInChunk;
     private convertEmptyCategory;
     private convertChunk;
+    private shouldChunkClaimToken;
     private removeTemporaryEdges;
     private generateChunkId;
     private generateTokenId;
     private generateLeafId;
     private findParent;
+    private findContainingChunks;
+    private findTightestContainingChunk;
+    private tightestChunk;
     private initTree;
     private sortChunks;
     private convertToken;

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

@@ -160,7 +160,7 @@ export default class CytoscapeTreeConverter {
         });
         const tokens = this.getTokens(struct, chunk);
         for (const token of tokens) {
-            if (token.ec)
+            if (!this.shouldChunkClaimToken(struct, chunk, token))
                 continue;
             tree.edges.push({
                 data: {
@@ -171,6 +171,20 @@ export default class CytoscapeTreeConverter {
             });
         }
     }
+    shouldChunkClaimToken(struct, chunk, token) {
+        if (token.ec)
+            return false;
+        if (token.l === 0 && chunk.l > 0) {
+            const dominator = this.findTightestContainingChunk(struct, token.p, token.p);
+            return (dominator !== null &&
+                this.generateChunkId(dominator) === this.generateChunkId(chunk));
+        }
+        if (token.l !== chunk.l)
+            return false;
+        const dominator = this.tightestChunk(this.findContainingChunks(struct, chunk.l, token.p, token.p));
+        return (dominator !== null &&
+            this.generateChunkId(dominator) === this.generateChunkId(chunk));
+    }
     removeTemporaryEdges(tree, struct, chunk) {
         let levelCount = 1;
         let leveledChunks = this.getChunksByLevel(struct, chunk, levelCount);
@@ -178,14 +192,16 @@ export default class CytoscapeTreeConverter {
             for (const upperChunk of leveledChunks) {
                 const upperChunkId = this.generateChunkId(upperChunk);
                 for (const token of this.getTokens(struct, chunk)) {
+                    if (!this.shouldChunkClaimToken(struct, chunk, token))
+                        continue;
                     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++;
+            leveledChunks = this.getChunksByLevel(struct, chunk, levelCount);
         }
     }
     generateChunkId(chunk) {
@@ -212,18 +228,26 @@ export default class CytoscapeTreeConverter {
         return `${token.p}`;
     }
     findParent(struct, chunk) {
-        const chunks = this.getChunksByLevel(struct, chunk, 1);
+        return this.tightestChunk(this.findContainingChunks(struct, chunk.l - 1, chunk.i, chunk.f));
+    }
+    findContainingChunks(struct, level, i, f) {
+        return struct.chunks.filter((c) => c.l === level && i >= c.i && f <= c.f);
+    }
+    findTightestContainingChunk(struct, i, f, minLevel = 1) {
+        return this.tightestChunk(struct.chunks.filter((c) => c.l >= minLevel && i >= c.i && f <= c.f));
+    }
+    tightestChunk(chunks) {
         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;
+        return chunks.reduce((best, c) => {
+            const span = c.f - c.i;
+            const bestSpan = best.f - best.i;
+            if (span < bestSpan)
+                return c;
+            if (span > bestSpan)
+                return best;
+            return c.i > best.i ? c : best;
+        });
     }
     initTree(struct) {
         this.sortChunks(struct);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tycho-components",
   "private": false,
-  "version": "0.25.12",
+  "version": "0.26.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -55,8 +55,8 @@
     "cytoscape-dagre": "^2.5.0",
     "cytoscape-node-html-label": "^1.2.2",
     "date-fns": "^4.1.0",
-    "driver.js": "^1.4.0",
     "date-fns-tz": "^3.2.0",
+    "driver.js": "^1.4.0",
     "file-saver": "^2.0.5",
     "html2canvas": "^1.4.1",
     "js-cookie": "^3.0.5",
@@ -112,6 +112,7 @@
     "storybook": "^10.1.11",
     "typescript": "^5.7.3",
     "vite": "^7.0.0",
+    "vitest": "^3.2.6",
     "wavesurfer-react": "^2.2.2",
     "wavesurfer.js": "^6.6.3"
   },
@@ -120,6 +121,7 @@
     "build-storybook": "storybook build",
     "build": "tsc && node scripts/copy-package-json.js && npm run copy-css",
     "build-publish": "tsc && npm run copy-css",
-    "copy-css": "node scripts/copy-css.js"
+    "copy-css": "node scripts/copy-css.js",
+    "test": "vitest run"
   }
 }