@abi-software/map-utilities 1.6.0-beta.1 → 1.6.1-beta.0

package/package.json

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

package/src/components/CompetencyQueries/CompetencyQueries.js

@@ -0,0 +1,180 @@
+/**
+ * Competency Queries
+ *
+ * competencyQuery: base function
+ * query[functionName]: specific queries
+ *
+ * Note: use named-export for better tree-shaking.
+ */
+
+async function postRequest(API_URL, payload) {
+  try {
+    const response = await fetch(API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      throw new Error(`API Error: ${response.status} ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error("Request failed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Competency Query
+ *
+ * @param {Object} options - Query options.
+ * @param {string} options.flatmapAPI - Base URL of the flatmap server.
+ * @param {string} options.knowledgeSource - SCKAN source ID.
+ * @param {string} options.queryId - Competency query ID.
+ * @param {Array} options.parameters - Parameters specific to the query.
+ * @param {string} [options.orderId] - Optional order ID for sorting.
+ * @returns {Promise<any>} - JSON response.
+ */
+async function competencyQuery(options) {
+  const { flatmapAPI, knowledgeSource, queryId, parameters, orderId } = options;
+  const API_URL = `${flatmapAPI}competency/query`;
+
+  const params = Array.isArray(parameters) ? [...parameters] : [];
+
+  params.push({
+    "column": "source_id",
+    "value": knowledgeSource,
+  });
+
+  let queryIdStr;
+  if (typeof queryId === 'number') {
+    queryIdStr = queryId.toString();
+  } else if (typeof queryId === 'string') {
+    queryIdStr = queryId;
+  } else {
+    throw new TypeError('queryId must be a string or a number convertible to string.');
+  }
+
+  const payload = {
+    "query_id": queryIdStr,
+    "parameters": params,
+  };
+
+  // Currently only query 12 has an order parameter
+  if (orderId) {
+    payload.order = [orderId];
+  }
+
+  return postRequest(API_URL, payload);
+}
+
+// Neuron populations associated with a location [query id => 1] (or)
+// Neuron populations that share at least one edge with another neuron population [query id => 23]
+async function queryAllConnectedPaths(flatmapAPI, knowledgeSource, featureId) {
+  const featureIds = Array.isArray(featureId) ? featureId : [featureId];
+  const queryId = featureIds[0].startsWith('ilxtr:') ? 23 : 1;
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: queryId,
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureIds
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+// Neuron populations beginning at a location
+async function queryPathsByOrigin(flatmapAPI, knowledgeSource, featureId) {
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 1, // TODO: to update to a specific query ID for origins
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureId
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+// Neuron populations via a location
+async function queryPathsByViaLocation(flatmapAPI, knowledgeSource, featureId) {
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 1, // TODO: to update to a specific query ID for via
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureId
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+// Neuron populations terminating at a location
+async function queryPathsByDestination(flatmapAPI, knowledgeSource, featureId) {
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 2,
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureId
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+export {
+  competencyQuery,
+  queryAllConnectedPaths,
+  queryPathsByOrigin,
+  queryPathsByViaLocation,
+  queryPathsByDestination,
+};

package/src/components/CompetencyQueries/knowledgeQueries.js

@@ -0,0 +1,160 @@
+// origins = ilxtr:hasSomaLocatedIn
+// destinations = ilxtr:hasAxonPresynapticElementIn, ilxtr:hasAxonSensorySubcellularElementIn
+// via = ilxtr:hasAxonLeadingToSensorySubcellularElementIn, ilxtr:hasAxonLocatedIn
+
+function filterOrigins(item) {
+  const soma = item["node-phenotypes"]?.["ilxtr:hasSomaLocatedIn"];
+  return Array.isArray(item.connectivity) &&
+    item.connectivity.length > 0 &&
+    Array.isArray(soma) &&
+    soma.length > 0;
+}
+
+function filterDestinations(item) {
+  const axonPresyn = item["node-phenotypes"]?.["ilxtr:hasAxonPresynapticElementIn"];
+  const axonSensory = item["node-phenotypes"]?.["ilxtr:hasAxonSensorySubcellularElementIn"];
+  const hasDest =
+    (Array.isArray(axonPresyn) && axonPresyn.length > 0) ||
+    (Array.isArray(axonSensory) && axonSensory.length > 0);
+  return Array.isArray(item.connectivity) &&
+    item.connectivity.length > 0 &&
+    hasDest;
+}
+
+function filterViaLocations(item) {
+  if (!Array.isArray(item.connectivity) || item.connectivity.length === 0) return false;
+
+  const origins = new Set(
+    (item["node-phenotypes"]?.["ilxtr:hasSomaLocatedIn"] || []).map(arr => arr[0])
+  );
+  const destinations = new Set([
+    ...((item["node-phenotypes"]?.["ilxtr:hasAxonPresynapticElementIn"] || []).map(arr => arr[0])),
+    ...((item["node-phenotypes"]?.["ilxtr:hasAxonSensorySubcellularElementIn"] || []).map(arr => arr[0]))
+  ]);
+
+  return item.connectivity.some(pair => {
+    const [from, to] = pair;
+    const fromId = from[0];
+    const toId = to[0];
+    return (
+      !origins.has(fromId) &&
+      !destinations.has(toId)
+    );
+  });
+}
+
+function getConnectivityItems(obj) {
+  if (!Array.isArray(obj.connectivity)) return [];
+  const items = new Set();
+
+  obj.connectivity.forEach((pair) => {
+    if (Array.isArray(pair) && pair.length) {
+      pair.forEach((endpoint) => {
+        if (Array.isArray(endpoint) && typeof endpoint[0] === 'string') {
+          const stringifyEndpoint = JSON.stringify(endpoint);
+          items.add(stringifyEndpoint);
+        }
+      });
+    }
+  });
+  return Array.from(items);
+}
+
+function getPhenotypeItems(obj, prop) {
+  const arr = obj["node-phenotypes"]?.[prop];
+  if (!Array.isArray(arr)) return [];
+  return arr;
+}
+
+function extractOriginItems(knowledge) {
+  const results = [];
+  knowledge.forEach(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
+    const connectivityItems = new Set(getConnectivityItems(obj));
+    getPhenotypeItems(obj, "ilxtr:hasSomaLocatedIn").forEach((item) => {
+      const stringifyItem = JSON.stringify(item);
+      if (connectivityItems.has(stringifyItem)) results.push(item);
+    });
+  });
+  return Array.from(
+    new Map(results.map(item => [JSON.stringify(item), item])).values()
+  );
+}
+
+function extractDestinationItems(knowledge) {
+  const results = [];
+  knowledge.forEach(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
+    const connectivityItems = new Set(getConnectivityItems(obj));
+    [
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonPresynapticElementIn"),
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonSensorySubcellularElementIn")
+    ].forEach(item => {
+      const stringifyItem = JSON.stringify(item);
+      if (connectivityItems.has(stringifyItem)) results.push(item);
+    });
+  });
+  return Array.from(
+    new Map(results.map(item => [JSON.stringify(item), item])).values()
+  );
+}
+
+function extractViaItems(knowledge) {
+  const results = [];
+  knowledge.forEach(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
+    const connectivityItems = new Set(getConnectivityItems(obj));
+    [
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonLeadingToSensorySubcellularElementIn"),
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonLocatedIn")
+    ].forEach(item => {
+      const stringifyItem = JSON.stringify(item);
+      if (connectivityItems.has(stringifyItem)) results.push(item);
+    });
+  });
+  return Array.from(
+    new Map(results.map(item => [JSON.stringify(item), item])).values()
+  );
+}
+
+function findPathsByOriginItem(knowledge, originItem) {
+  return knowledge.filter(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return false;
+    const origins = getPhenotypeItems(obj, "ilxtr:hasSomaLocatedIn");
+    return origins.some(item => JSON.stringify(item) === JSON.stringify(originItem));
+  });
+}
+
+function findPathsByDestinationItem(knowledge, destinationItem) {
+  return knowledge.filter(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return false;
+    const destinations = [
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonPresynapticElementIn"),
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonSensorySubcellularElementIn")
+    ];
+    return destinations.some(item => JSON.stringify(item) === JSON.stringify(destinationItem));
+  });
+}
+
+function findPathsByViaItem(knowledge, viaItem) {
+  return knowledge.filter(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return false;
+    const vias = [
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonLeadingToSensorySubcellularElementIn"),
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonLocatedIn")
+    ];
+    return vias.some(item => JSON.stringify(item) === JSON.stringify(viaItem));
+  });
+}
+
+export {
+  filterOrigins,
+  filterDestinations,
+  filterViaLocations,
+  extractOriginItems,
+  extractDestinationItems,
+  extractViaItems,
+  findPathsByOriginItem,
+  findPathsByDestinationItem,
+  findPathsByViaItem,
+}

package/src/components/index.js

@@ -8,6 +8,24 @@ import HelpModeDialog from "./HelpModeDialog/HelpModeDialog.vue";
 import Tooltip from "./Tooltip/Tooltip.vue";
 import TreeControls from "./TreeControls/TreeControls.vue";
 import ExternalResourceCard from "./Tooltip/ExternalResourceCard.vue";
+import {
+  competencyQuery,
+  queryAllConnectedPaths,
+  queryPathsByOrigin,
+  queryPathsByViaLocation,
+  queryPathsByDestination,
+} from "./CompetencyQueries/CompetencyQueries.js";
+import {
+  filterOrigins,
+  filterDestinations,
+  filterViaLocations,
+  extractOriginItems,
+  extractDestinationItems,
+  extractViaItems,
+  findPathsByOriginItem,
+  findPathsByDestinationItem,
+  findPathsByViaItem,
+} from "./CompetencyQueries/knowledgeQueries.js";
 
 export {
   AnnotationPopup,
@@ -20,4 +38,18 @@ export {
   Tooltip,
   TreeControls,
   ExternalResourceCard,
+  competencyQuery,
+  queryAllConnectedPaths,
+  queryPathsByOrigin,
+  queryPathsByViaLocation,
+  queryPathsByDestination,
+  filterOrigins,
+  filterDestinations,
+  filterViaLocations,
+  extractOriginItems,
+  extractDestinationItems,
+  extractViaItems,
+  findPathsByOriginItem,
+  findPathsByDestinationItem,
+  findPathsByViaItem,
 };