phyloio 2.1.0 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phyloio",
-  "version": "2.1.0",
+  "version": "2.2.2",
   "description": "JS library for visualising and comparing phylogenetic trees",
   "scripts": {
     "test": "npm run-script build-jest; jest --silent=false",

package/rerooting.test.js

@@ -0,0 +1,297 @@
+/**
+ * @jest-environment jsdom
+ */
+
+
+const PhyloIO = require("./dist-jest/phylo.js").PhyloIO;
+const utils = require('./src/utils.js')
+
+var data = '((C,D)1,(A,(B,X)3)2,E);'
+
+// get string made of concatenation  of leaves name from node.leaves
+const getSortedLeaves = (node) => {
+    return node.leaves.map(leaf => leaf.name).sort();
+}
+
+const verify_boostrap_default = (node, children) =>  {
+
+    var con_leaves = getSortedLeaves(node)
+
+    if ( con_leaves.length <= 1) {
+        return;
+    }
+
+    var str_leaves = JSON.stringify(con_leaves);
+
+    switch (str_leaves){
+        case JSON.stringify(['A', 'B', 'X']):
+            expect(node.extended_informations.Data).toBe("2");
+            break;
+        case JSON.stringify(['B', 'X']):
+            expect(node.extended_informations.Data).toBe("3");
+            break;
+        case JSON.stringify(['C', 'D']):
+            expect(node.extended_informations.Data).toBe("1");
+            break;
+        case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+            expect(node.extended_informations.Data).toBeUndefined();
+            break;
+        default:
+            expect(true).toBe(false);
+            break
+    }
+}
+
+test('test reroot on X' , () => {
+
+    const phylo = PhyloIO.init();
+
+    // >>>  test with  internal label for branches
+    var m1 = phylo._create_model(data, {'data_type' : 'nhx'})
+    m1.settings.edge_related_data.push('Data');
+    m1.traverse(m1.data,verify_boostrap_default);
+
+    // reroot on X
+    var x_node = m1.data.leaves.find(leaf => leaf.name === 'X');
+    m1.reroot(x_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBeUndefined();
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+    // >>> test without internal label for branches
+    var m2 = phylo._create_model(data, {'data_type' : 'nhx'})
+    m2.traverse(m2.data,verify_boostrap_default);
+
+    // reroot on X
+    var x_node2 = m2.data.leaves.find(leaf => leaf.name === 'X');
+    m2.reroot(x_node2);
+    m2.traverse(m2.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBeUndefined()
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeUndefined();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+})
+
+test('test reroot on B/X > C/D > B/X ' , () => {
+
+    const phylo = PhyloIO.init();
+
+    // >>>  test with  internal label for branches
+    var m1 = phylo._create_model(data, {'data_type' : 'nhx'})
+    m1.settings.edge_related_data.push('Data');
+    m1.traverse(m1.data,verify_boostrap_default);
+
+    // reroot on BX
+    var bx_node = null;
+    m1.traverse(m1.data, function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        if (str_leaves === JSON.stringify(['B', 'X'])) {
+            bx_node = node;
+        }
+    });
+    m1.reroot(bx_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            case JSON.stringify(['B', 'X']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+    // reroot on CD
+    var cd_node = null;
+    m1.traverse(m1.data, function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        if (str_leaves === JSON.stringify(['C', 'D'])) {
+            cd_node = node;
+        }
+    });
+    m1.reroot(cd_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['A', 'B', 'X']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'B', 'E', 'X']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['B', 'X']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+    // reroot on BX
+    var bx2_node = null;
+    m1.traverse(m1.data, function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        console.log(str_leaves)
+
+        if (str_leaves === JSON.stringify(['B', 'X'])) {
+
+            bx2_node = node;
+        }
+    });
+    m1.reroot(bx2_node);
+    m1.traverse(m1.data,function(node, children) {
+
+        var con_leaves = getSortedLeaves(node)
+
+        if ( con_leaves.length <= 1) {
+            return;
+        }
+
+        var str_leaves = JSON.stringify(con_leaves);
+
+        switch (str_leaves){
+            case JSON.stringify(['C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("2");
+                break;
+            case JSON.stringify(['C', 'D']):
+                expect(node.extended_informations.Data).toBe("1");
+                break;
+            case JSON.stringify(['A', 'B', 'C', 'D', 'E', 'X']):
+                expect(node.extended_informations.Data).toBeNull();
+                break;
+            case JSON.stringify(['A', 'C', 'D', 'E']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            case JSON.stringify(['B', 'X']):
+                expect(node.extended_informations.Data).toBe("3");
+                break;
+            default:
+                expect(true).toBe(false);
+                break
+        }
+    });
+
+
+})
+
+
+
+
+
+
+

package/src/api.js

@@ -11,6 +11,7 @@ export default class API {
     constructor() {
 
         this.settings = {
+            'version' : 1,
             'phylostratigraphy' : false,
             'share_phylo': ' https://beta.phylo.io/viewer/',
             'share_post': ' https://beta.phylo.io/sharing/create/',
@@ -59,6 +60,7 @@ export default class API {
         this.bound_container = [] // pair of container used for distance computation
         this.session_token = null // unique session token for cloud saving
         this.session_url = null // url for cloud saving
+        this.session_answer = null; // data from reply when generating session
         this.phylo_embedded = false // phylo.io website mode
         this.distance = {
             'RF' : false,
@@ -418,7 +420,7 @@ export default class API {
 
     screen_shot(params){screen_shot(params)}
 
-    generate_share_link(){
+    generate_share_link(callback){
 
         var that = this
         var xhr = new XMLHttpRequest();
@@ -428,22 +430,30 @@ export default class API {
             if (this.readyState != 4) return;
 
             else if (this.status == 201) {
-                var data = JSON.parse(this.responseText);
-
-                if (data.result = 'OK'){
-                    that.session_token = data.session
-                    that.session_url = that.settings.share_phylo + '?session=' + that.session_token
+                let data = JSON.parse(this.responseText);
+                that.session_answer = data;
+                if (data.result === 'OK'){
+                    that.token = data.session;
+                    that.session_url = that.settings.share_phylo + '?session=' + data.session;
                 }
             }
 
             else if (this.status == 413) {
-                that.session_token = 'ERROR_SIZE';
-                return
+                let data = JSON.parse(this.responseText);
+                that.session_url = 'ERROR_SIZE';
+                that.session_answer = data;
             }
 
             else if (this.status == 400) {
-                return
+                let data = JSON.parse(this.responseText) | {result: "Error", message: "The server does not accept this session data"};
+                that.session_answer = data
+                that.session_url = ""
+            }
+            else {
+                that.session_answer = {result: "Error", message: "The server is currently not available."}
+                that.session_url = ""
             }
+            callback(that)
         };
 
         xhr.open("POST", this.settings.share_post, false);