@teselagen/bio-parsers 0.1.27 → 0.1.28

package/src/geneiousXmlToJson.js

@@ -0,0 +1,147 @@
+/* eslint-disable no-var*/
+
+import validateSequenceArray from "./utils/validateSequenceArray";
+import {
+  searchWholeObjByNameSimple,
+  searchWholeObjByNameSimpleArray
+} from "./utils/searchWholeObjByName";
+
+import { XMLParser } from "fast-xml-parser";
+import { forEach, flatMap } from "lodash";
+import { filter } from "lodash";
+
+//Here's what should be in the callback:
+// {
+//   parsedSequence:
+//   messages:
+//   success:
+// }
+async function geneiousXmlToJson(string, options) {
+  options = options || {};
+
+  const onFileParsed = function (sequences) {
+    //before we call the onFileParsed callback, we need to validate the sequence
+    return validateSequenceArray(sequences, options);
+  };
+
+  try {
+    const result = new XMLParser({
+      isArray: () => true
+    }).parse(string);
+    const geneiousJsonMatches = searchWholeObjByNameSimpleArray(
+      "geneiousDocument",
+      result
+    );
+
+    const resultArray = [];
+    if (!geneiousJsonMatches?.length) {
+      return onFileParsed({
+        success: false,
+        messages: ["Error: XML is not valid geneious format"]
+      });
+    }
+    forEach(geneiousJsonMatches, (geneiousJson) => {
+      const response = {
+        parsedSequence: null,
+        messages: [],
+        success: true
+      };
+      try {
+        response.parsedSequence = parseGeneiousJson(geneiousJson, options);
+        resultArray.push(response);
+      } catch (e) {
+        console.error("error:", e);
+        console.error("error.stack: ", e.stack);
+        resultArray.push({
+          success: false,
+          messages: ["Error while parsing Geneious format"]
+        });
+      }
+    });
+    const toRet = filter(
+      resultArray,
+      (r) => r?.parsedSequence?.sequence?.length
+    );
+    if (toRet.length) return toRet;
+    return onFileParsed(resultArray);
+  } catch (e) {
+    console.error(`e:`, e);
+    return onFileParsed({
+      success: false,
+      messages: ["Error parsing geneious to JSON"]
+    });
+  }
+}
+function parseGeneiousJson(geneiousJson) {
+  const circular = searchWholeObjByNameSimple("isCircular", geneiousJson);
+
+  let geneiousJsonInner = searchWholeObjByNameSimple(
+    "originalElement",
+    geneiousJson
+  );
+  geneiousJsonInner = searchWholeObjByNameSimple(
+    "XMLSerialisableRootElement",
+    geneiousJsonInner
+  );
+
+  const sequence = searchWholeObjByNameSimple(
+    "charSequence",
+    geneiousJsonInner
+  );
+  const features = flatMap(
+    searchWholeObjByNameSimpleArray("annotation", geneiousJsonInner),
+    function (feature) {
+      if (feature) {
+        const name = (
+          searchWholeObjByNameSimple("description", feature) || ""
+        ).substring(0, 255);
+        const intervals = searchWholeObjByNameSimpleArray("interval", feature);
+        const type = searchWholeObjByNameSimple("type", feature);
+        const firstInterval = intervals[0];
+        const lastInterval = intervals[intervals.length - 1];
+        const start =
+          searchWholeObjByNameSimple("minimumIndex", firstInterval) - 1;
+        const end =
+          searchWholeObjByNameSimple("maximumIndex", lastInterval) - 1;
+        let locations;
+        if (intervals.length > 1) {
+          locations = intervals.map((i) => {
+            const start = searchWholeObjByNameSimple("minimumIndex", i) - 1;
+            const end = searchWholeObjByNameSimple("maximumIndex", i) - 1;
+            return {
+              start,
+              end
+            };
+          });
+        }
+        const strand =
+          searchWholeObjByNameSimple("direction", firstInterval) ===
+          "leftToRight"
+            ? 1
+            : -1;
+        const arrowheadType =
+          searchWholeObjByNameSimple("direction", firstInterval) === "none"
+            ? "NONE"
+            : undefined;
+        return {
+          name,
+          type,
+          locations,
+          arrowheadType,
+          start,
+          end,
+          strand
+        };
+      }
+    }
+  );
+  const name = searchWholeObjByNameSimple("name", geneiousJsonInner);
+  return {
+    sequence,
+    circular,
+    name: name,
+    features
+  };
+}
+
+export default geneiousXmlToJson;

package/src/gffToJson.js

@@ -0,0 +1,43 @@
+import gff from "@gmod/gff";
+import _ from "lodash";
+
+function gffToJson(string) {
+  const arrayOfThings = gff.parseStringSync(string);
+  const results = [];
+  const sequences = [];
+  const features = {};
+  arrayOfThings.forEach((featureOrSeq) => {
+    if (featureOrSeq.sequence) {
+      sequences.push(featureOrSeq);
+    } else {
+      const feature = featureOrSeq[0];
+      if (!features[feature.seq_id]) features[feature.seq_id] = [];
+      const attributes = feature.attributes || {};
+      const name = _.get(attributes, "ID[0]");
+      features[feature.seq_id].push({
+        name,
+        start: feature.start,
+        end: feature.end,
+        strand: feature.strand === "+" ? 1 : -1,
+        type: feature.type,
+      });
+    }
+  });
+  sequences.forEach((sequence) => {
+    const sequenceId = sequence.id;
+    const result = {
+      messages: [],
+      success: true,
+      parsedSequence: {
+        name: sequenceId,
+        sequence: sequence.sequence,
+        circular: false,
+        features: features[sequence.id],
+      },
+    };
+    results.push(result);
+  });
+  return results;
+}
+
+export default gffToJson;

package/src/index.js

@@ -0,0 +1,23 @@
+export { default as anyToJson } from "./anyToJson";
+export { default as fastaToJson } from "./fastaToJson";
+export { default as genbankToJson } from "./genbankToJson";
+export { default as sbolXmlToJson } from "./sbolXmlToJson";
+export { default as geneiousXmlToJson } from "./geneiousXmlToJson";
+export { default as jbeiXmlToJson } from "./jbeiXmlToJson";
+export { default as jsonToGenbank } from "./jsonToGenbank";
+export {
+  default as ab1ToJson,
+  convertBasePosTraceToPerBpTrace
+} from "./ab1ToJson";
+export { default as jsonToFasta } from "./jsonToFasta";
+export { default as snapgeneToJson } from "./snapgeneToJson";
+export { default as jsonToBed } from "./jsonToBed";
+export { default as cleanUpTeselagenJsonForExport } from "./utils/cleanUpTeselagenJsonForExport";
+export {
+  default as searchWholeObjByName,
+  searchWholeObjByNameSimple,
+  searchWholeObjByNameSimpleArray
+} from "./utils/searchWholeObjByName";
+export { default as parseUracilFeatures } from "./utils/parseUracilFeatures";
+export { default as jsonToJsonString } from "./jsonToJsonString";
+export { default as validateSequenceArray } from "./utils/validateSequenceArray";

package/src/jbeiXmlToJson.js

@@ -0,0 +1,109 @@
+/* eslint-disable no-var*/
+
+import validateSequenceArray from "./utils/validateSequenceArray";
+import { XMLParser } from "fast-xml-parser";
+import { filter } from "lodash";
+
+//Here's what should be in the callback:
+// {
+//   parsedSequence:
+//   messages:
+//   success:
+// }
+async function jbeiXmlToJson(string, options) {
+  options = options || {};
+
+  const onFileParsed = function (sequences) {
+    //before we call the onFileParsed callback, we need to validate the sequence
+    return validateSequenceArray(sequences, options);
+  };
+
+  try {
+    const res = new XMLParser({}).parse(string);
+    const jbeiSeq = res["seq:seq"];
+    const resultArray = [];
+    if (!jbeiSeq) {
+      return onFileParsed({
+        success: false,
+        messages: ["Error: XML is not valid jbei format"],
+      });
+    }
+
+    const response = {
+      parsedSequence: null,
+      messages: [],
+      success: true,
+    };
+    try {
+      response.parsedSequence = parseJbeiXml(jbeiSeq, options);
+      resultArray.push(response);
+    } catch (e) {
+      console.error("error:", e);
+      console.error("error.stack: ", e.stack);
+      resultArray.push({
+        success: false,
+        messages: ["Error while parsing JBEI format"],
+      });
+    }
+
+    const toRet = filter(
+      resultArray,
+      (r) => r?.parsedSequence?.sequence?.length
+    );
+    if (toRet.length) return toRet;
+    return onFileParsed(resultArray);
+  } catch (e) {
+    console.error(`e:`, e);
+    return onFileParsed({
+      success: false,
+      messages: ["Error parsing jbei to JSON"],
+    });
+  }
+}
+function parseJbeiXml(jbeiJson) {
+  const {
+    "seq:sequence": sequence,
+    "seq:name": name,
+    "seq:circular": circular,
+    "seq:features": { "seq:feature": features },
+  } = jbeiJson;
+  return {
+    sequence,
+    circular,
+    name: name,
+    features: (Array.isArray(features) ? features : [features]).map(
+      ({
+        "seq:complement": complement,
+        "seq:label": label,
+        "seq:type": type,
+        "seq:location": jbeiLocations,
+      }) => {
+        let start, end;
+        const locs = Array.isArray(jbeiLocations)
+          ? jbeiLocations
+          : [jbeiLocations];
+        const locations = locs.map(
+          ({ "seq:genbankStart": gbStart, "seq:end": normEnd }, i) => {
+            if (i === 0) start = gbStart - 1;
+            if (i === locs.length - 1) end = normEnd - 1;
+            return {
+              start: gbStart - 1,
+              end: normEnd - 1,
+            };
+          }
+        );
+
+        return {
+          start,
+          end,
+          locations: locations.length > 1 ? locations : undefined,
+          name: label,
+          type,
+          strand: complement ? -1 : 1,
+        };
+      }
+    ),
+  };
+}
+
+export default jbeiXmlToJson;

package/src/jsonToBed.js

@@ -0,0 +1,39 @@
+import { tidyUpSequenceData } from "@teselagen/sequence-utils";
+
+function jsonToBed(jsonSequence, options = {}) {
+  const sequenceInfo = options.featuresOnly
+    ? jsonSequence
+    : tidyUpSequenceData(jsonSequence);
+  const { name, features, size, description, circular } = sequenceInfo;
+
+  let sequenceNameToMatchFasta = "";
+  sequenceNameToMatchFasta += `${name || "Untitled Sequence"}|`;
+  sequenceNameToMatchFasta += "|" + size;
+  sequenceNameToMatchFasta += description ? "|" + description : "";
+  sequenceNameToMatchFasta += "|" + (circular ? "circular" : "linear");
+  const sequenceNameToUse = options.sequenceName || sequenceNameToMatchFasta;
+  let outString = "";
+  outString += `track name="${sequenceNameToUse}" description="${name} Annotations" itemRgb="On"\n`;
+
+  features.forEach(function(feat) {
+    const { start, end, name, type, forward, strand } = feat;
+    const label = name ? name : type;
+    let orientation;
+    if (forward || strand === 1) {
+      orientation = "+";
+    } else if (!forward || strand === -1) {
+      orientation = "-";
+    } else {
+      // "." = no strand
+      orientation = ".";
+    }
+    const color = type === "CDS" ? "230,88,0" : "";
+    // chromStart is 0-based, chromEnd of the BED file format is not included in the feature
+    // when there is no thick part, thickStart and thickEnd are usually set to the chromStart position
+    outString += `${sequenceNameToUse}\t${start}\t${end +
+      1}\t${label}\t\t${orientation}\t\t\t${color}\n`;
+  });
+  return outString;
+}
+
+export default jsonToBed;

package/src/jsonToFasta.js

@@ -0,0 +1,33 @@
+import { tidyUpSequenceData } from "@teselagen/sequence-utils";
+import { mangleOrStripUrls } from "./utils/unmangleUrls";
+
+export default function jsonToFasta(jsonSequence, options) {
+  const cleanedData = tidyUpSequenceData(jsonSequence);
+  const {
+    name,
+    circular,
+    description,
+    size,
+    sequence,
+    isProtein,
+    proteinSize,
+    proteinSequence,
+  } = cleanedData;
+
+  options = options || {};
+  let seqToUse = sequence;
+  let sizeToUse = size;
+  if (isProtein && proteinSequence) {
+    seqToUse = proteinSequence;
+    sizeToUse = proteinSize;
+  }
+  // options.reformatSeqName = options.reformatSeqName === false ? false : true;
+  let fastaString = "";
+  fastaString += `>${name || "Untitled Sequence"}|`;
+  fastaString += "|" + sizeToUse;
+  fastaString += description ? "|" + mangleOrStripUrls(description, options) : "";
+  fastaString += "|" + (circular ? "circular" : "linear");
+  fastaString += "\n";
+  fastaString += (seqToUse.match(/.{1,80}/g) || []).join("\n");
+  return fastaString;
+}