@figtreejs/core 0.0.1-alpha.0

package/src/evo/tree/normalized-tree/index.ts

@@ -0,0 +1,3 @@
+// export {NormalizedTree} from "./normalizedTree"
+// export * from "./normalizedTree.types"
+export * from "./immutable-tree";

package/src/evo/tree/parsers/annotation-parser.ts

@@ -0,0 +1,276 @@
+import type {
+  Annotation,
+  MarkovJumpValue,
+  RawAnnotationValue,
+  ValueOf,
+} from "../tree-types";
+import { BaseAnnotationType } from "../tree-types";
+
+/** What the *parser* can emit before classification */
+
+export type ClassifiedValue =
+  | {
+      type: BaseAnnotationType.DISCRETE;
+      value: ValueOf<BaseAnnotationType.DISCRETE>;
+    }
+  | {
+      type: BaseAnnotationType.NUMERICAL;
+      value: ValueOf<BaseAnnotationType.NUMERICAL>;
+    }
+  | {
+      type: BaseAnnotationType.BOOLEAN;
+      value: ValueOf<BaseAnnotationType.BOOLEAN>;
+    }
+  | {
+      type: BaseAnnotationType.NUMERICAL_SET;
+      value: ValueOf<BaseAnnotationType.NUMERICAL_SET>;
+    }
+  | {
+      type: BaseAnnotationType.DISCRETE_SET;
+      value: ValueOf<BaseAnnotationType.DISCRETE_SET>;
+    }
+  | {
+      type: BaseAnnotationType.MARKOV_JUMPS;
+      value: ValueOf<BaseAnnotationType.MARKOV_JUMPS>;
+    }
+  | {
+      type: BaseAnnotationType.DENSITIES;
+      value: ValueOf<BaseAnnotationType.DENSITIES>;
+    };
+
+type ParsedAnnotationRaw = Record<string, RawAnnotationValue>;
+
+// Parse the annotation found in a nexus (or newick string - perish the thought!)
+export function parseAnnotation(annotationString: string): ParsedAnnotationRaw {
+  const tokens = annotationString
+    .split(/\s*('[^']+'|"[^"]+"|;|\(|\)|,|:|=|\[&|\]|\{|\})\s*/)
+    .filter((token) => token.length > 0);
+  let annotationKeyNext = true;
+  let annotationKey: string = "";
+  let isAnnotationARange = false;
+  let inSubRange = false;
+  let subValue: string[] = [];
+  let value: RawAnnotationValue | undefined = undefined;
+  const annotations: ParsedAnnotationRaw = {};
+
+  // expect the first token to be a [& and last ]
+  if (tokens[0] !== "[&" || tokens[tokens.length - 1] !== "]") {
+    throw new Error(
+      "expecting a [& at the start and ] at the end of the annotation",
+    );
+  }
+  for (const token of tokens) {
+    if (token === "[&") {
+      // open BEAST annotation
+      annotationKeyNext = true;
+    } else if (token === "=") {
+      annotationKeyNext = false;
+    } else if (token === ",") {
+      if (!isAnnotationARange) {
+        annotationKeyNext = true;
+
+        if (value === undefined) throw new Error(`Empty annotation value`);
+        //finalize annotation
+        annotations[annotationKey] = value;
+      } else {
+        continue; //to next value in range
+      }
+    } else if (token === "{") {
+      if (isAnnotationARange) {
+        inSubRange = true;
+        subValue = [];
+      } else {
+        value = [];
+      }
+      isAnnotationARange = true;
+    } else if (token === "}") {
+      if (inSubRange) {
+        inSubRange = false;
+        // eslint-disable-next-line
+        (value as any[])!.push(subValue);
+      } else {
+        isAnnotationARange = false;
+      }
+    } else if (token === "]") {
+      // close BEAST annotation
+
+      //finalize annotation
+      if (value === undefined) throw new Error(`Empty annotation value`);
+      annotations[annotationKey] = value;
+    } else {
+      // must be annotation
+      // remove any quoting and then trim whitespace
+      let annotationToken = token;
+      if (annotationToken.startsWith('"') || annotationToken.startsWith("'")) {
+        annotationToken = annotationToken.slice(1);
+      }
+      if (annotationToken.endsWith('"') || annotationToken.endsWith("'")) {
+        annotationToken = annotationToken.slice(0, -1);
+      }
+      if (annotationKeyNext) {
+        annotationKey = annotationToken.replace(".", "_");
+      } else {
+        if (isAnnotationARange) {
+          if (inSubRange) {
+            subValue.push(annotationToken);
+          } else {
+            // eslint-disable-next-line
+            (value as any[]).push(annotationToken);
+          }
+        } else {
+          if (isNaN(annotationToken as unknown as number)) {
+            value = annotationToken;
+          } else {
+            value = parseFloat(annotationToken);
+          }
+        }
+      }
+    }
+  }
+  return annotations;
+}
+
+export function processAnnotationValue(
+  values: RawAnnotationValue,
+): ClassifiedValue {
+  if (Array.isArray(values)) {
+    // if is it an array it could be markov jump or array of values
+    // is a set of  values
+    //Array of array?
+    if (Array.isArray(values[0])) {
+      // an array of arrays is a markov jump
+      // This may be a markov jump array
+      const tuples = values as string[][];
+
+      if (
+        tuples
+          .map((v) => v.length === 3)
+          .reduce((acc, curr) => acc && curr, true)
+      ) {
+        const jumps: MarkovJumpValue[] = tuples.map(
+          ([timeStr, source, dest]) => {
+            const timeNum = Number(timeStr);
+            if (!Number.isFinite(timeNum)) {
+              throw new Error(
+                `Expected a markov jump annotation but the first entry ${timeStr} could not be make a number`,
+              );
+            }
+            return { time: timeNum, from: source, to: dest };
+          },
+        );
+        return { type: BaseAnnotationType.MARKOV_JUMPS, value: jumps };
+      } else {
+        throw Error(
+          `Markov jump with dimension ${tuples[0].length} detected. Expected 3. ${tuples.map((t) => t.length).join(",")}`,
+        );
+      }
+    }
+    // Flat array check types
+    const flat = values as Array<string | number>;
+
+    const allStrings = flat.every((v) => typeof v === "string");
+    const allNumbersAfterCoerce = flat.every((v) => Number.isFinite(Number(v)));
+
+    if (allNumbersAfterCoerce) {
+      const nums = flat.map((v) => Number(v));
+      return { type: BaseAnnotationType.NUMERICAL_SET, value: nums };
+    }
+
+    if (allStrings) {
+      return {
+        type: BaseAnnotationType.DISCRETE_SET,
+        value: flat.slice(),
+      };
+    }
+
+    // coerce to strings
+    return {
+      type: BaseAnnotationType.DISCRETE_SET,
+      value: flat.map(String),
+    };
+    // densities
+  } else if (isPlainObject(values)) {
+    // is a set of properties with values
+
+    const obj = values as Record<string, string | number | boolean>;
+    const entries = Object.entries(obj);
+
+    const allNumbers = entries.every(([, v]) => Number.isFinite(Number(v)));
+    const allBooleans = entries.every(([, v]) => typeof v === "boolean");
+
+    if (allNumbers) {
+      const probs: Record<string, number> = {};
+      for (const [k, v] of entries) {
+        const n = Number(v);
+        probs[k] = n;
+      }
+      return { type: BaseAnnotationType.DENSITIES, value: probs };
+    }
+
+    if (allBooleans) {
+      const set = entries
+        .filter(([, v]) => v === true)
+        .map(([k]) => k)
+        .sort();
+      return { type: BaseAnnotationType.DISCRETE_SET, value: set };
+    }
+
+    throw new Error(
+      "Unsupported object value: expected numeric (probabilities) or boolean map",
+    );
+  } else {
+    if (typeof values === "boolean") {
+      return { type: BaseAnnotationType.BOOLEAN, value: values };
+    }
+
+    if (typeof values === "number") {
+      return { type: BaseAnnotationType.NUMERICAL, value: values };
+    }
+
+    if (typeof values === "string") {
+      // try boolean literal
+      const lower = values.toLowerCase();
+      if (lower === "true" || lower === "false") {
+        return { type: BaseAnnotationType.BOOLEAN, value: lower === "true" };
+      }
+      // try number
+      const n = Number(values);
+      if (Number.isFinite(n)) {
+        return { type: BaseAnnotationType.NUMERICAL, value: n };
+      }
+
+      // otherwise discrete label
+      return { type: BaseAnnotationType.DISCRETE, value: values };
+    }
+  }
+  throw new Error(`Unsupported annotation value: ${String(values)}`);
+}
+
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+export function writeAnnotationValue(a: Annotation): string {
+  switch (a.type) {
+    case BaseAnnotationType.DISCRETE:
+      return a.value;
+    case BaseAnnotationType.BOOLEAN:
+      return String(a.value);
+    case BaseAnnotationType.NUMERICAL:
+      return String(a.value);
+    case BaseAnnotationType.NUMERICAL_SET:
+      return "{" + a.value.map((d) => String(d)).join(", ") + "}";
+    case BaseAnnotationType.DISCRETE_SET:
+      return "{" + a.value.join(", ") + "}";
+    case BaseAnnotationType.MARKOV_JUMPS:
+      return (
+        "{" +
+        a.value.map((d) => `{${String(d.time)},${d.from},${d.to}}`).join(", ") +
+        "}"
+      );
+    case BaseAnnotationType.DENSITIES:
+      throw new Error(
+        `No defined why to write densities (${a.id}) as a string. \n Please convert keys and values to separate array annotations.`,
+      );
+  }
+}

package/src/evo/tree/parsers/index.ts

@@ -0,0 +1,3 @@
+export * from "./annotation-parser";
+export * from "./newick-parsing";
+export * from "./nexus-parsing";

package/src/evo/tree/parsers/newick-character-parser.ts

@@ -0,0 +1,246 @@
+import type { Taxon } from "../taxa/taxon";
+import { TaxonSet } from "../taxa/taxon";
+import type { NodeRef } from "../tree-types";
+import { ImmutableTree } from "../normalized-tree/immutable-tree";
+import { parseAnnotation } from "./annotation-parser";
+import { notNull, unNullify } from "../../../utils";
+
+export class NewickCharacterParser {
+  done: boolean;
+  started: boolean;
+  level: number;
+  currentNode: NodeRef | undefined;
+  nodeStack: NodeRef[];
+  labelNext: boolean;
+  lengthNext: boolean;
+  taxonSet: TaxonSet;
+  tree: ImmutableTree;
+  options: { labelName?: string; translateTaxonNames?: Map<string, string> };
+  constructor(
+    taxonSet: TaxonSet = new TaxonSet(),
+    options: {
+      labelName?: string;
+      translateTaxonNames?: Map<string, string>;
+    } = {},
+  ) {
+    this.done = false;
+    this.started = false;
+    this.level = 0;
+    this.currentNode = undefined;
+    this.nodeStack = [];
+    this.labelNext = false;
+    this.lengthNext = false;
+    this.taxonSet = taxonSet;
+    this.options = options;
+    this.tree = new ImmutableTree({ taxonSet: this.taxonSet });
+  }
+  isDone() {
+    return this.done;
+  }
+  isStarted() {
+    return this.started;
+  }
+  getTree(): ImmutableTree {
+    if (!this.done) {
+      throw new Error("expecting a semi-colon at the end of the newick string");
+    }
+    if (!this.started) {
+      throw new Error("No tree to give - parsing has not started.");
+    }
+    //set hights
+
+    return this.tree;
+  }
+
+  parseCharacter(t: string): void {
+    if (this.done) {
+      throw new Error("Parsing is done. We have seen a ';'");
+    }
+    if (t.length > 2 && t.substring(0, 2) === "[&") {
+      const annotations = parseAnnotation(t);
+
+      // for(const annotation of annotations){
+      notNull(
+        this.currentNode,
+        "Internal Parsing error - Current not is not defined",
+      );
+      this.tree = this.tree.annotateNode(
+        this.currentNode,
+        annotations,
+      ) as ImmutableTree;
+      // }
+    } else if (t === ";") {
+      // check if done.
+      //set done.
+      if (this.level > 0) {
+        throw new Error(
+          `unexpected semi-colon in tree did not reach the root yet`,
+        );
+      }
+      if (!this.started) {
+        throw new Error(
+          `unexpected semi-colon in tree parsing has not started yet`,
+        );
+      }
+      this.done = true;
+    } else if (t === "(") {
+      // an internal node
+      this.started = true;
+      if (this.labelNext) {
+        // if labelNext is set then the last bracket has just closed
+        // so there shouldn't be an open bracket.
+        throw new Error("expecting a comma");
+      }
+      let node;
+      this.level += 1;
+      if (this.currentNode !== undefined) {
+        const added = this.tree.addNodes(1);
+        this.tree = added.tree;
+        node = added.nodes[0];
+        this.nodeStack.push(this.currentNode);
+      } else {
+        node = this.tree.getRoot();
+      }
+      this.currentNode = node;
+    } else if (t === ",") {
+      // another branch in an internal node
+
+      this.labelNext = false; // labels are optional
+      if (this.lengthNext) {
+        throw new Error("branch length missing");
+      }
+
+      const parent = this.nodeStack.pop();
+      notNull(parent, `Internal Parsing error - node stack unexpectedly empty`);
+      notNull(
+        this.currentNode,
+        "Internal Parsing error - Current not is not defined",
+      );
+      this.tree = this.tree.addChild(parent, this.currentNode);
+      // tree.setParent(currentNode!,parent)
+
+      this.currentNode = parent;
+    } else if (t === ")") {
+      if (this.level === 0) {
+        throw new Error(
+          "the brackets in the newick file are not balanced: too many closed",
+        );
+      }
+      // finished an internal node
+
+      this.labelNext = false; // labels are optional
+      if (this.lengthNext) {
+        throw new Error("branch length missing");
+      }
+
+      // the end of an internal node
+      const parent = this.nodeStack.pop();
+
+      notNull(parent, `Internal Parsing error - node stack unexpectedly empty`);
+      notNull(
+        this.currentNode,
+        "Internal Parsing error - Current not is not defined",
+      );
+      this.tree = this.tree.addChild(parent, this.currentNode);
+      // tree.setParent(currentNode!,parent)
+
+      this.level -= 1;
+      this.currentNode = parent;
+
+      this.labelNext = true;
+    } else if (t === ":") {
+      this.labelNext = false; // labels are optional
+      this.lengthNext = true;
+    } else {
+      // not any specific token so may be a label, a length, or an external node name
+      if (this.lengthNext) {
+        notNull(
+          this.currentNode,
+          "Internal Parsing error - Current not is not defined",
+        );
+        this.tree = this.tree.setLength(this.currentNode, parseFloat(t));
+        this.lengthNext = false;
+      } else if (this.labelNext) {
+        if (!t.startsWith("#")) {
+          let value: number | string = parseFloat(t);
+          if (isNaN(value)) {
+            value = t;
+          }
+          if (this.options.labelName) {
+            notNull(
+              this.currentNode,
+              "Internal Parsing error - Current not is not defined",
+            );
+            this.tree = this.tree.annotateNode(
+              this.currentNode,
+              this.options.labelName,
+              value,
+            ) as ImmutableTree;
+          } else {
+            console.warn(
+              `No label name provided to newick parser but found label ${t}. It will be ignored`,
+            );
+          }
+        } else {
+          notNull(
+            this.currentNode,
+            "Internal Parsing error - Current not is not defined",
+          );
+          this.tree = this.tree.setLabel(this.currentNode, t.slice(1)); //remove the # todo put it back when writing to newick
+        }
+        this.labelNext = false;
+      } else {
+        let name = t; // TODO tree needs be a map that's not the ID
+
+        // remove any quoting and then trim whitespace
+        // TODO add to bit that parses taxa block
+        if (name.startsWith('"') || name.startsWith("'")) {
+          name = name.slice(1);
+        }
+        if (name.endsWith('"') || name.endsWith("'")) {
+          name = name.slice(0, -1);
+        }
+        name = name.trim();
+
+        const added = this.tree.addNodes(1);
+        this.tree = added.tree;
+        const externalNode = added.nodes[0];
+        let taxon: Taxon;
+        if (this.options.translateTaxonNames) {
+          if (this.options.translateTaxonNames.has(name)) {
+            name = unNullify(
+              this.options.translateTaxonNames.get(name),
+              `${name} not found in taxon translation map`,
+            );
+          } else {
+            throw new Error(
+              `No mapping found for ${name} in tipNameMap. It's name will not be updated`,
+            );
+          }
+        }
+
+        if (this.taxonSet.isFinalized) {
+          // if set then it will be finalised by now.
+
+          if (!this.taxonSet.hasTaxon(name)) {
+            // hmm trees won't have
+            throw new Error(
+              `Taxon ${name} not found in taxa - but found in tree`,
+            );
+          }
+          taxon = this.taxonSet.getTaxonByName(name);
+        } else {
+          this.taxonSet.addTaxon(name);
+          taxon = this.taxonSet.getTaxonByName(name);
+        }
+
+        this.tree = this.tree.setTaxon(externalNode, taxon);
+
+        if (this.currentNode) {
+          this.nodeStack.push(this.currentNode);
+        }
+        this.currentNode = externalNode;
+      }
+    }
+  }
+}

package/src/evo/tree/parsers/newick-parsing.ts

@@ -0,0 +1,22 @@
+import { NewickCharacterParser } from "./newick-character-parser";
+import type { ImmutableTree, newickParsingOptions } from "..";
+import { TaxonSet } from "..";
+
+export function parseNewick(
+  newick: string,
+  options: newickParsingOptions = {},
+): ImmutableTree {
+  const taxonSet = options.taxonSet ? options.taxonSet : new TaxonSet();
+  const tokens = newick
+    .split(/\s*('[^']+'|"[^"]+"|\[&[^[]+]|,|:|\)|\(|;)\s*/)
+    .filter((token) => token.length > 0);
+
+  const parser = new NewickCharacterParser(taxonSet, options);
+
+  for (const token of tokens) {
+    parser.parseCharacter(token);
+  }
+  const tree = parser.getTree();
+
+  return tree;
+}

package/src/evo/tree/parsers/nexus-parser.ts

@@ -0,0 +1,12 @@
+export default class NexusParser {
+  // get lock on file
+  // only read when asked for tree.
+  tokens: string[];
+  constructor(contents: string) {
+    this.tokens = contents
+      .split(
+        /\s*(?:\bBegin\s+|\bbegin\s+|\bBEGIN\s+|\bend\s*;|\bEnd\s*;|\bEND\s*;)\s*/,
+      )
+      .filter((d) => d !== "");
+  }
+}

package/src/evo/tree/parsers/nexus-parsing.ts

@@ -0,0 +1,68 @@
+/* eslint-disable */
+import { ImmutableTree } from "../normalized-tree/immutable-tree";
+import { parseNewick } from "./newick-parsing";
+
+//ONLY parses the first tree
+export function parseNexus(
+  _tree: ImmutableTree,
+  nexus: string,
+  options = {},
+): ImmutableTree {
+  // odd parts ensure we're not in a taxon label
+  //TODO make this parsing more robust
+  const nexusTokens = nexus
+    .split(
+      /\s*(?:\bBegin\s+|\bbegin\s+|\bBEGIN\s+|\bend\s*;|\bEnd\s*;|\bEND\s*;)\s*/,
+    )
+    .filter((d) => d !== "");
+  if (nexusTokens.length === 0 || nexusTokens === undefined) {
+    throw new Error(
+      "No nexus tokens found in string. This may not be a nexus formated tree",
+    );
+  }
+  const firstToken = nexusTokens.shift()!.trim();
+  if (firstToken.toLowerCase() !== "#nexus") {
+    throw Error("File does not begin with #NEXUS is it a nexus file?");
+  }
+  for (const section of nexusTokens) {
+    const workingSection = section.replace(/^\s+|\s+$/g, "").split(/\n/);
+    const sectionTitle = workingSection.shift()!;
+    if (sectionTitle.toLowerCase().trim() === "trees;") {
+      let inTaxaMap = false;
+      const tipNameMap = new Map();
+      for (const token of workingSection) {
+        if (token.trim().toLowerCase() === "translate") {
+          inTaxaMap = true;
+        } else {
+          if (inTaxaMap) {
+            if (token.trim() === ";") {
+              inTaxaMap = false;
+            } else {
+              const taxaData = token
+                .trim()
+                .replace(",", "")
+                .split(/\s*\s\s*/);
+              tipNameMap.set(taxaData[0], taxaData[1]);
+            }
+          } else {
+            const treeString = token.substring(token.indexOf("("));
+            if (tipNameMap.size > 0) {
+              return parseNewick(treeString, {
+                parseAnnotations: true,
+                ...options,
+                tipNameMap: tipNameMap,
+              });
+            } else {
+              return parseNewick(treeString, {
+                parseAnnotations: true,
+                ...options,
+                tipNameMap: tipNameMap,
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  throw new Error("No tree section found in nexus file");
+}