@abi-software/map-utilities 1.6.1-beta.6 → 1.6.1-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abi-software/map-utilities",
-  "version": "1.6.1-beta.6",
+  "version": "1.6.1-beta.8",
   "files": [
     "dist/*",
     "src/*",

package/src/components/CompetencyQueries/CompetencyQueries.js

@@ -272,17 +272,14 @@ async function queryPathsByRoute({ flatmapAPI, knowledgeSource, origins, destina
     {
       column: 'source_feature_id',
       value: originFeatureIds,
-      ...(originFeatureIds.length === 0 && { negate: true })
     },
     {
       column: 'via_feature_id',
       value: viaFeatureIds,
-      ...(viaFeatureIds.length === 0 && { negate: true })
     },
     {
       column: 'dest_feature_id',
       value: destinationFeatureIds,
-      ...(destinationFeatureIds.length === 0 && { negate: true })
     }
   ];
 
@@ -290,17 +287,14 @@ async function queryPathsByRoute({ flatmapAPI, knowledgeSource, origins, destina
     {
       column: 'source_node_id',
       value: origins,
-      ...(origins.length === 0 && { negate: true })
     },
     {
       column: 'via_node_id',
       value: vias,
-      ...(vias.length === 0 && { negate: true })
     },
     {
       column: 'dest_node_id',
       value: destinations,
-      ...(destinations.length === 0 && { negate: true })
     }
   ];
 

package/src/components/CompetencyQueries/flatmapQueries.js

@@ -0,0 +1,37 @@
+const CachedTaxonLabels = [];
+
+async function findTaxonomyLabels (mapImp, taxonomies) {
+  const intersectionTaxonomies = taxonomies.filter((taxonomy) =>
+    CachedTaxonLabels.some((obj) => obj.taxon === taxonomy)
+  );
+
+  const foundCachedTaxonLabels = CachedTaxonLabels.filter((obj) =>
+    intersectionTaxonomies.includes(obj.taxon)
+  );
+
+  const leftoverTaxonomies = taxonomies.filter((taxonomy) =>
+    !intersectionTaxonomies.includes(taxonomy)
+  );
+
+  if (!leftoverTaxonomies.length) {
+    return foundCachedTaxonLabels;
+  } else {
+    const entityLabels = await mapImp.queryLabels(leftoverTaxonomies);
+    if (entityLabels.length) {
+      entityLabels.forEach((entityLabel) => {
+        let { entity: taxon, label } = entityLabel;
+        if (label === 'Mammalia') {
+          label = 'Mammalia not otherwise specified'
+        }
+        const item = { taxon, label };
+        foundCachedTaxonLabels.push(item);
+        CachedTaxonLabels.push(item);
+      });
+      return foundCachedTaxonLabels;
+    }
+  }
+}
+
+export {
+  findTaxonomyLabels,
+}

package/src/components/CompetencyQueries/knowledgeQueries.js

@@ -2,6 +2,8 @@
 // destinations = ilxtr:hasAxonPresynapticElementIn, ilxtr:hasAxonSensorySubcellularElementIn
 // via = ilxtr:hasAxonLeadingToSensorySubcellularElementIn, ilxtr:hasAxonLocatedIn
 
+import { findTaxonomyLabels } from "./flatmapQueries";
+
 async function query(flatmapAPI, sql, params) {
   const url = `${flatmapAPI}knowledge/query/`;
   const query = { sql, params };
@@ -242,6 +244,154 @@ async function queryPathsByRouteFromKnowledge({ knowledge, origins, destinations
   return results;
 }
 
+async function getFlatmapFilterOptions (flatmapAPI, mapImp, providedKnowledge, providedPathways) {
+  let filterOptions = [];
+  const connectionFilters = [];
+
+  if (mapImp) {
+    // get flatmap filters
+    if (mapImp && typeof mapImp.featureFilterRanges === 'function') {
+      const filterRanges = mapImp.featureFilterRanges();
+      for (const [key, value] of Object.entries(filterRanges)) {
+        let main = {
+          key: `flatmap.connectivity.${key}`,
+          label: "",
+          children: []
+        }
+        let children = []
+        if (key === "kind") {
+          main.label = "Pathways"
+          for (const facet of value) {
+            const pathway = providedPathways.find(path => path.type === facet)
+            if (pathway) {
+              children.push({
+                key: `${main.key}.${facet}`,
+                label: pathway.label,
+                colour: pathway.colour,
+                colourStyle: 'line',
+                dashed: pathway.dashed,
+              })
+            }
+          }
+        } else if (key === "taxons") {
+          main.label = "Studied in"
+          const entityLabels = await findTaxonomyLabels(mapImp, mapImp.taxonIdentifiers)
+          if (entityLabels.length) {
+            for (const facet of value) {
+              const taxon = entityLabels.find(p => p.taxon === facet)
+              if (taxon) {
+                children.push({
+                  key: `${main.key}.${facet}`,
+                  // space added at the end of label to make sure the display name will not be updated
+                  // prevent sidebar searchfilter convertReadableLabel
+                  label: `${taxon.label} `
+                })
+              }
+            }
+          }
+        } else if (key === "alert") {
+          main.label = "Alert"
+          for (const facet of ["with", "without"]) {
+            children.push({
+              key: `${main.key}.${facet}`,
+              label: `${facet} alerts`
+            })
+          }
+        }
+        main.children = children.sort((a, b) => a.label.localeCompare(b.label));
+        if (main.label && main.children.length) {
+          filterOptions.push(main)
+        }
+      }
+    }
+
+    const mapKnowledge = mapImp.pathways.paths;
+    const flatmapKnowledge = providedKnowledge.reduce((arr, knowledge) => {
+      const id = knowledge.id;
+      if (id) {
+        const mapKnowledgeObj = mapKnowledge[id];
+        if (mapKnowledgeObj && mapKnowledgeObj.connectivity && mapKnowledgeObj['node-phenotypes']) {
+          const mapConnectivity = mapKnowledgeObj.connectivity;
+          const mapNodePhenotypes = mapKnowledgeObj['node-phenotypes'];
+          // take only map connectivity
+          knowledge.connectivity = [...mapConnectivity];
+          for (let key in knowledge['node-phenotypes']) {
+            if (mapNodePhenotypes[key]) {
+              // take only map node-phenotypes
+              knowledge['node-phenotypes'][key] = [...mapNodePhenotypes[key]];
+            }
+          }
+          // to avoid mutation
+          arr.push(JSON.parse(JSON.stringify(knowledge)));
+        }
+      }
+      return arr;
+    }, []);
+    const knowledgeSource = mapImp.knowledgeSource;
+    const originItems = await extractOriginItems(flatmapAPI, knowledgeSource, flatmapKnowledge);
+    const viaItems = await extractViaItems(flatmapAPI, knowledgeSource, flatmapKnowledge);
+    const destinationItems = await extractDestinationItems(flatmapAPI, knowledgeSource, flatmapKnowledge);
+
+    const transformItem = (facet, item) => {
+      const key = JSON.stringify(item.key);
+      return {
+        key: `flatmap.connectivity.source.${facet}.${key}`,
+        label: item.label || key
+      };
+    }
+
+    for (const facet of ["origin", "via", "destination", "all"]) {
+      let childrenList = []
+      if (facet === 'origin') {
+        childrenList = originItems.map((item) => transformItem(facet, item));
+      } else if (facet === 'via') {
+        childrenList = viaItems.map((item) => transformItem(facet, item));
+      } else if (facet === 'destination') {
+        childrenList = destinationItems.map((item) => transformItem(facet, item));
+      } else {
+        // All is the combination of origin, via, destination
+        const allList = [
+          ...originItems.map((item) => transformItem(facet, item)),
+          ...viaItems.map((item) => transformItem(facet, item)),
+          ...destinationItems.map((item) => transformItem(facet, item))
+        ];
+        // Generate unique list since the same feature can be in origin, via, and destination
+        const seenKeys = new Set();
+        childrenList = allList.filter(item => {
+          if (seenKeys.has(item.key)) return false;
+          seenKeys.add(item.key);
+          return true;
+        });
+      }
+
+      // Those without label but key should be below
+      childrenList = childrenList.sort((a, b) => {
+        const isAlpha = (str) => /^[a-zA-Z]/.test(str);
+        const aAlpha = isAlpha(a.label);
+        const bAlpha = isAlpha(b.label);
+
+        if (aAlpha && !bAlpha) return -1;
+        if (!aAlpha && bAlpha) return 1;
+
+        return a.label.localeCompare(b.label);
+      });
+
+      if (childrenList.length) {
+        connectionFilters.push({
+          key: `flatmap.connectivity.source.${facet}`,
+          label: facet,
+          children: childrenList,
+        })
+      }
+    }
+
+    if (connectionFilters.length) {
+      filterOptions.push(...connectionFilters)
+    }
+  }
+  return filterOptions;
+}
+
 export {
   filterOrigins,
   filterDestinations,
@@ -254,4 +404,5 @@ export {
   findPathsByViaItem,
   queryPathsByRouteFromKnowledge,
   fetchLabels,
+  getFlatmapFilterOptions,
 }

package/src/components/index.js

@@ -29,6 +29,7 @@ import {
   findPathsByViaItem,
   queryPathsByRouteFromKnowledge,
   fetchLabels,
+  getFlatmapFilterOptions,
 } from "./CompetencyQueries/knowledgeQueries.js";
 
 export {
@@ -60,4 +61,5 @@ export {
   findPathsByViaItem,
   queryPathsByRouteFromKnowledge,
   fetchLabels,
+  getFlatmapFilterOptions,
 };