@figtreejs/core 0.0.1-alpha.0

package/src/evo/tree/taxa/taxon.ts

@@ -0,0 +1,116 @@
+import { MaybeType } from "@figtreejs/maybe/maybe";
+import { maybeGetNameFromIndex, maybeGetTaxonByName } from "./helper-functions";
+
+export interface Taxon {
+  name: string;
+  number: number;
+  annotations: { [annotation: string]: string | string[] | number | number[] };
+}
+
+function newTaxon(name: string, number: number): Taxon {
+  return {
+    name,
+    number,
+    annotations: {},
+  };
+}
+
+export interface TaxonSetInterface {
+  addTaxon(name: string): TaxonSetInterface;
+  getTaxon(id: number): Taxon | undefined;
+  getTaxonByName(name: string): Taxon;
+  getTaxonCount(): number;
+  lockTaxa(): TaxonSetInterface;
+}
+
+export interface TaxonSetData {
+  allNames: string[];
+  byName: { [taxon: string]: Taxon };
+  finalized: boolean;
+}
+export class TaxonSet implements TaxonSetInterface {
+  _data: TaxonSetData;
+  constructor(taxonSetData?: TaxonSetData) {
+    this._data = taxonSetData
+      ? taxonSetData
+      : {
+          allNames: [],
+          byName: {},
+          finalized: false,
+        };
+  }
+  lockTaxa(): TaxonSetInterface {
+    if (!this._data.finalized) {
+      this._data.finalized = true;
+    }
+    return this;
+  }
+  addTaxon(taxonOrName: string | Taxon): this {
+    if (this._data.finalized) {
+      throw new Error("Cannot add taxon to finalized set");
+    }
+    let taxon: Taxon;
+    if (typeof taxonOrName === "string") {
+      const name = taxonOrName;
+
+      if (Object.prototype.hasOwnProperty.call(this._data.byName, name)) {
+        throw new Error(
+          `taxon ${name} already exists in the set. Names must be unique`,
+        );
+      }
+
+      taxon = newTaxon(name, this._data.allNames.length);
+    } else {
+      taxon = taxonOrName;
+      if (Object.prototype.hasOwnProperty.call(this._data.byName, taxon.name)) {
+        throw new Error(
+          `taxon ${taxon.name} already exists in the set. Names must be unique`,
+        );
+      }
+      if (
+        this._data.allNames[taxon.number] &&
+        this._data.allNames[taxon.number] !== taxon.name
+      ) {
+        throw new Error(
+          `taxon number ${taxon.number} already exists in the set with name ${this._data.allNames[taxon.number]}. Taxon numbers must be unique`,
+        );
+      }
+      console.log("Adding existing taxon:", taxon.name);
+    }
+    this._data.allNames[taxon.number] = taxon.name;
+    this._data.byName[taxon.name] = taxon;
+    return this;
+  }
+
+  getTaxon(id: number): Taxon {
+    const taxon = maybeGetTaxonByName(
+      this._data,
+      maybeGetNameFromIndex(this._data, id),
+    );
+    switch (taxon.type) {
+      case MaybeType.Some:
+        return taxon.value;
+      case MaybeType.Nothing:
+        throw new Error(`Taxon by name ${id} not found`); // won't get here I dont' think
+    }
+  }
+  getTaxonByName(name: string): Taxon {
+    const taxon = maybeGetTaxonByName(this._data, name);
+    switch (taxon.type) {
+      case MaybeType.Some:
+        return taxon.value;
+      case MaybeType.Nothing:
+        throw new Error(`Taxon by name ${name} not found`);
+    }
+  }
+  hasTaxon(id: string): boolean {
+    return Object.prototype.hasOwnProperty.call(this._data.byName, id);
+  }
+
+  getTaxonCount(): number {
+    return this._data.allNames.length;
+  }
+  get isFinalized() {
+    return this._data.finalized;
+  }
+}

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

@@ -0,0 +1 @@
+export { PreOrderTraversalCache } from "./preorder-traversal";

package/src/evo/tree/traversals/preorder-traversal.ts

@@ -0,0 +1,89 @@
+import type { Tree, NodeRef } from "../tree-types";
+import type { TreeTraversal } from "./traversal-types";
+export class PreOrderTraversalCache implements TreeTraversal {
+  _forwardCache: Map<NodeRef, NodeRef>;
+  _reverseCache: Map<NodeRef, NodeRef>;
+  constructor() {
+    this._forwardCache = new Map();
+    this._reverseCache = new Map();
+  }
+
+  *traverse(tree: Tree, node?: NodeRef): Generator<NodeRef> {
+    const traverse = function* (node: NodeRef): Generator<NodeRef> {
+      const childCount = tree.getChildCount(node);
+
+      if (childCount > 0) {
+        for (let i = 0; i < childCount; i++) {
+          const child = tree.getChild(node, i);
+          yield* traverse(child);
+        }
+      }
+      yield node;
+    };
+    if (node === undefined) {
+      node = tree.getRoot();
+    }
+    yield* traverse(node);
+  }
+
+  //Check we've been to next otherwise we need to update again.
+  getNext(tree: Tree, node: NodeRef): NodeRef | undefined {
+    const n = this._forwardCache.get(node);
+    if (n !== undefined) {
+      if (this._forwardCache.get(n) !== undefined) {
+        return n; //if this node hasn't changed nor the next
+      }
+    }
+
+    if (tree.isRoot(node)) {
+      //start over
+      return undefined;
+    }
+    const parent = tree.getParent(node);
+    if (tree.hasRightSibling(node)) {
+      const rs = tree.getRightSibling(node);
+      this._forwardCache.set(node, rs);
+      this._reverseCache.set(rs, node);
+    } else {
+      this._forwardCache.set(node, parent);
+      this._reverseCache.set(parent, node);
+    }
+
+    return this._forwardCache.get(node);
+  }
+  getPrevious(tree: Tree, node: NodeRef): NodeRef | undefined {
+    const n = this._reverseCache.get(node);
+    if (n !== undefined) {
+      if (this._reverseCache.get(n) !== undefined) {
+        return n; //if this node hasn't changed nor the next
+      }
+    }
+    if (node === this.traverse(tree).next().value) {
+      return undefined;
+    }
+    if (tree.isInternal(node)) {
+      const childCount = tree.getChildCount(node) - 1;
+      const lastChild = tree.getChild(node, childCount);
+      this._reverseCache.set(node, lastChild);
+      this._forwardCache.set(lastChild, node);
+    } else {
+      if (tree.hasLeftSibling(node)) {
+        const ls = tree.getLeftSibling(node);
+        this._reverseCache.set(node, ls);
+        this._forwardCache.set(ls, node);
+      } else {
+        let n = node;
+        while (!tree.hasLeftSibling(n)) {
+          // aunt = tree.getLeftSibling(n);
+          n = tree.getParent(n);
+        }
+        const aunt = tree.getLeftSibling(n);
+        this._reverseCache.set(node, aunt);
+        this._forwardCache.set(aunt, node);
+        // look for parent's left sibling if none try again until root
+        // if at and no ls error we are at first tip and should have caught this above.
+      }
+    }
+    return this._reverseCache.get(node);
+  }
+}

package/src/evo/tree/traversals/traversal-types.ts

@@ -0,0 +1,6 @@
+import type { NodeRef, Tree } from "../tree-types";
+
+export interface TreeTraversal {
+  getNext(tree: Tree, node: NodeRef): NodeRef | undefined;
+  getPrevious(tree: Tree, node: NodeRef): NodeRef | undefined;
+}

package/src/evo/tree/tree-types.ts

@@ -0,0 +1,197 @@
+import type { Taxon, TaxonSet } from "./taxa/taxon";
+
+export interface NodeRef {
+  number: number;
+  _id: string;
+}
+export enum BaseAnnotationType {
+  DISCRETE = "DISCRETE", // string  could also be stringy numbers
+  BOOLEAN = "BOOLEAN", // true false
+  NUMERICAL = "NUMERICAL", // float
+
+  NUMERICAL_SET = "NUMERICAL_SET", // number[]
+  DISCRETE_SET = "DISCRETE_SET", // string[]
+
+  MARKOV_JUMPS = "MARKOV_JUMPS", // {from: to: time:}
+  DENSITIES = "DENSITIES", // Record<string, number>
+}
+export type MarkovJumpValue = { from: string; to: string; time?: number };
+
+export type ValueOf<T extends BaseAnnotationType> =
+  T extends BaseAnnotationType.DISCRETE
+    ? string
+    : T extends BaseAnnotationType.BOOLEAN
+      ? boolean
+      : T extends BaseAnnotationType.NUMERICAL
+        ? number
+        : T extends BaseAnnotationType.NUMERICAL_SET
+          ? number[]
+          : T extends BaseAnnotationType.DISCRETE_SET
+            ? string[]
+            : T extends BaseAnnotationType.MARKOV_JUMPS
+              ? MarkovJumpValue[]
+              : T extends BaseAnnotationType.DENSITIES
+                ? Record<string, number>
+                : never;
+
+export type RawValueOf<T extends BaseAnnotationType> =
+  T extends BaseAnnotationType.DISCRETE
+    ? string
+    : T extends BaseAnnotationType.BOOLEAN
+      ? boolean
+      : T extends BaseAnnotationType.NUMERICAL
+        ? number
+        : T extends BaseAnnotationType.NUMERICAL_SET
+          ? number[]
+          : T extends BaseAnnotationType.DISCRETE_SET
+            ? string[]
+            : T extends BaseAnnotationType.MARKOV_JUMPS
+              ? [number, string, string][] | [string, string, string][]
+              : T extends BaseAnnotationType.DENSITIES
+                ? Record<string, number>
+                : never;
+
+export type DomainOf<T extends BaseAnnotationType> =
+  T extends BaseAnnotationType.DISCRETE
+    ? string[]
+    : T extends BaseAnnotationType.BOOLEAN
+      ? [boolean, boolean]
+      : T extends BaseAnnotationType.NUMERICAL
+        ? [number, number]
+        : T extends BaseAnnotationType.NUMERICAL_SET
+          ? [number, number]
+          : T extends BaseAnnotationType.DISCRETE_SET
+            ? string[] | number[]
+            : T extends BaseAnnotationType.MARKOV_JUMPS
+              ? string[] // just locations
+              : T extends BaseAnnotationType.DENSITIES
+                ? string[] // just states
+                : never;
+
+/** A single, generic annotation, discriminated by `type`. */
+export type AbstractAnnotation<T extends BaseAnnotationType> = {
+  id: string;
+  type: T;
+  value: ValueOf<T>;
+};
+
+export type Annotation = {
+  [K in BaseAnnotationType]: AbstractAnnotation<K>;
+}[BaseAnnotationType];
+
+export interface AbstractAnnotationSummary<T extends BaseAnnotationType> {
+  id: string;
+  type: T;
+  domain: DomainOf<T>;
+}
+
+export type AnnotationDomain = {
+  [K in BaseAnnotationType]: DomainOf<K>;
+}[BaseAnnotationType];
+export type AnnotationValue = {
+  [K in BaseAnnotationType]: ValueOf<K>;
+}[BaseAnnotationType];
+export type AnnotationSummary = {
+  [K in BaseAnnotationType]: AbstractAnnotationSummary<K>;
+}[BaseAnnotationType];
+export type RawAnnotationValue = {
+  [K in BaseAnnotationType]: RawValueOf<K>;
+}[BaseAnnotationType];
+
+export interface newickParsingOptions {
+  dateFormat?: string;
+  datePrefix?: string;
+  labelName?: string;
+  parseAnnotations?: boolean;
+  tipNameMap?: Map<string, string>;
+  taxonSet?: TaxonSet;
+}
+export interface Tree {
+  getRoot(): NodeRef;
+  isRooted(): boolean;
+  getNodeCount(): number;
+  getInternalNodeCount(): number;
+  getExternalNodeCount(): number;
+  getNode(i: string | Taxon | number): NodeRef;
+  getInternalNodes(): NodeRef[];
+  getExternalNodes(): NodeRef[];
+  getNodes(): NodeRef[];
+  getTaxon(id: number | NodeRef): Taxon;
+
+  isExternal(node: NodeRef): boolean;
+  isInternal(node: NodeRef): boolean;
+  isRoot(node: NodeRef): boolean;
+
+  getChildCount(node: NodeRef): number;
+  getChild(node: NodeRef, i: number): NodeRef;
+
+  getNodeByTaxon(taxon: Taxon): NodeRef;
+  getNodeByLabel(label: string): NodeRef;
+  // getLevel(node:NodeRef):number;
+
+  getDivergence(node: NodeRef): number;
+  getHeight(node: NodeRef): number;
+  getLength(node: NodeRef): number;
+
+  getParent(node: NodeRef): NodeRef;
+  getChildren(node: NodeRef): NodeRef[];
+
+  getAnnotation(
+    node: NodeRef,
+    name: string,
+    d?: AnnotationValue,
+  ): AnnotationValue; // what about or undefined?
+  // getAnnotation<T extends BaseAnnotationType>(node: NodeRef, name: string, d:T): T
+
+  // getAnnotationValue<T extends BaseAnnotationType>(node:NodeRef, name:string,type:T):ValueOf<T>|undefined
+  // annotateNode<T extends BaseAnnotationType>(node:NodeRef,annotation:{name:string,value:RawValueOf<T>}):Tree
+  annotateNode(node: NodeRef, name: string, value: RawAnnotationValue): Tree;
+  annotateNode(
+    node: NodeRef,
+    annotation: Record<string, RawAnnotationValue>,
+  ): Tree;
+
+  getLabel(node: NodeRef): string;
+  hasLabel(node: NodeRef): boolean;
+
+  getAnnotationKeys(): string[];
+  getAnnotationType(name: string): BaseAnnotationType;
+
+  getAnnotations(): AnnotationSummary[];
+  getAnnotationSummary(name: string): AnnotationSummary;
+
+  addNodes(n?: number): { tree: Tree; nodes: NodeRef[] };
+  deleteNode(n: NodeRef): Tree;
+  removeChild(parent: NodeRef, child: NodeRef): Tree;
+  deleteClade(n: NodeRef): Tree;
+  // hasNextSibling(node:Node)
+  getNextSibling(node: NodeRef): NodeRef;
+  hasRightSibling(node: NodeRef): boolean;
+  getRightSibling(node: NodeRef): NodeRef;
+  hasLeftSibling(node: NodeRef): boolean;
+  getLeftSibling(node: NodeRef): NodeRef;
+
+  setHeight(node: NodeRef, height: number): Tree;
+  setDivergence(node: NodeRef, divergence: number): Tree;
+  setLength(node: NodeRef, length: number): Tree;
+  setTaxon(node: NodeRef, taxon: Taxon): Tree;
+  setLabel(node: NodeRef, label: string): Tree;
+
+  addChild(parent: NodeRef, child: NodeRef): Tree;
+  // root(node: NodeRef,portion:number): Tree
+  unroot(node: NodeRef): Tree;
+  toNewick(node?: NodeRef, options?: { includeAnnotations: boolean }): string;
+  orderNodesByDensity(down: boolean): Tree;
+  sortChildren(
+    node: NodeRef,
+    compare: (a: NodeRef, b: NodeRef) => number,
+  ): Tree;
+  isRoot(node: NodeRef): boolean;
+  getMRCA(node1: NodeRef, node2: NodeRef): NodeRef;
+  getMRCA(nodes: NodeRef[]): NodeRef;
+  rotate(node: NodeRef, recursive: boolean): Tree;
+  reroot(node: NodeRef, proportion: number): Tree;
+}
+export type TreeListener = (tree: Tree, node: NodeRef) => void;
+
+//TODO abstact Tree with parsing implementations

package/src/evo/tree/utilities.ts

@@ -0,0 +1,44 @@
+//https://stackoverflow.com/questions/27936772/how-to-deep-merge-instead-of-shallow-merge
+import { timeParse, timeFormat } from "d3-time-format";
+
+//https://stackoverflow.com/questions/29400171/how-do-i-convert-a-decimal-year-value-into-a-date-in-javascript
+/**
+ * Helper function to determine if the provided year is a leap year
+ * @param year
+ * @return {boolean}
+ */
+export function leapYear(year: number) {
+  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+
+/**
+ * A function which converts a decimal float into a date object
+ * @param decimalDate
+ * @return {Date}
+ */
+export function decimalToDate(decimal: number) {
+  const year = Math.trunc(decimal);
+  const totalNumberOfDays = leapYear(year) ? 366 : 365;
+  const day = Math.round((decimal - year) * totalNumberOfDays);
+  return timeParse("%Y-%j")(`${year}-${day}`);
+}
+
+/**
+ * A function that converts a date into a decimal.
+ * @param date
+ * @return {number}
+ */
+export function dateToDecimal(date: Date) {
+  const year = parseInt(timeFormat("%Y")(date));
+  const day = parseInt(timeFormat("%j")(date));
+  const totalNumberOfDays = leapYear(year) ? 366 : 365;
+  return year + day / totalNumberOfDays;
+}
+
+//https://stackoverflow.com/questions/526559/testing-if-something-is-a-class-in-javascript
+export function isFunction(funcOrClass: unknown) {
+  const propertyNames = Object.getOwnPropertyNames(funcOrClass);
+  return (
+    !propertyNames.includes("prototype") || propertyNames.includes("arguments")
+  );
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { FigTree } from "./components";
+export type { FigtreeProps } from "./components";
+export * from "./bauble-makers/makers";
+export * from "./evo";
+export * from "./layouts";
+export * from "./utils";

package/src/layouts/functional/index.ts

@@ -0,0 +1,2 @@
+export { rectangularLayout, polarLayout } from "./rectangular-layout";
+export { radialLayout } from "./radial-layout";

package/src/layouts/functional/radial-layout.ts

@@ -0,0 +1,150 @@
+// export function layout (tree:ImmutableTree,node?:NodeRef):Map<NodeRef,FunctionalVertex>{
+
+import type { ImmutableTree, NodeRef } from "../../evo";
+import { preOrderIterator, tipIterator } from "../../evo";
+import type { NodeLabelType } from "../types";
+import { notNull } from "../../utils";
+import type { FunctionalVertex } from "../types";
+import { layoutClass } from "../types";
+
+//       //todo set some map for fixing the traversal of the tree.
+//       const vertexMap = new Map();
+type data = {
+  angleStart: number;
+  angleEnd: number;
+  xpos: number;
+  ypos: number;
+  level: number;
+  number: number;
+};
+
+export function radialLayout(
+  tree: ImmutableTree,
+  options: { spread?: number } = {},
+): (node: NodeRef) => FunctionalVertex {
+  const { spread = 1 } = options;
+  console.log("radial layout with spread", spread);
+  const map = new Map<NodeRef, FunctionalVertex>();
+
+  const dataStack: data[] = [
+    {
+      angleStart: 0,
+      angleEnd: 2 * Math.PI,
+      xpos: 0,
+      ypos: 0,
+      level: 0,
+      number: tree.getRoot().number,
+    },
+  ]; // TODO start tree.
+  for (const node of preOrderIterator(tree)) {
+    const data = dataStack.pop();
+    notNull(data, `Internal Error, hit the end of the data stack unexpectedly`);
+    const { angleStart, angleEnd, xpos, ypos, level } = data;
+
+    const branchAngle = (angleStart + angleEnd) / 2.0;
+
+    const length = !tree.isRoot(node) ? tree.getLength(node) : 0;
+
+    const directionX = Math.cos(branchAngle);
+    const directionY = Math.sin(branchAngle);
+    const x = xpos + length * directionX;
+    const y = ypos + length * directionY;
+
+    const leftLabel = tree.getChildCount(node) > 0;
+    let dx, dy;
+    if (!leftLabel) {
+      dx = Math.cos(branchAngle);
+      dy = Math.sin(branchAngle);
+    } else {
+      dx = Math.cos(branchAngle);
+      dy = Math.sin(branchAngle);
+    }
+    const vertex = {
+      x,
+      y,
+      layoutClass: layoutClass.Radial,
+      theta: branchAngle,
+      nodeLabel: {
+        dxFactor: dx,
+        dyFactor: dy,
+        alignmentBaseline: "middle",
+        textAnchor:
+          normalizeAngle(branchAngle) > Math.PI / 2 &&
+          normalizeAngle(branchAngle) < (3 * Math.PI) / 2
+            ? "end"
+            : "start",
+        rotation: 0, // textSafeDegrees(normalizeAngle(branchAngle))
+      } as NodeLabelType,
+    };
+
+    if (tree.getChildCount(node) > 0) {
+      const childLeafs: number[] = [];
+      let totalLeafs = 0;
+      for (let i = 0; i < tree.getChildCount(node); i++) {
+        const leafCount = [...tipIterator(tree, tree.getChild(node, i))].length;
+        childLeafs[i] = leafCount;
+        totalLeafs += leafCount;
+      }
+
+      let span = angleEnd - angleStart;
+      let updatedAngleStart = angleStart;
+
+      if (tree.getRoot() !== node) {
+        // span *= 1.0 + ((safeOpts.spread * Math.PI / 180) / 10.0);
+        span *= 1.0 + (spread * Math.PI) / 180 / 10.0;
+        updatedAngleStart = branchAngle - span / 2.0;
+      }
+
+      let a2 = updatedAngleStart;
+
+      for (let i = tree.getChildCount(node) - 1; i > -1; i--) {
+        // i think we need to go in reverse order here
+        const a1 = a2;
+        a2 = a1 + (span * childLeafs[i]) / totalLeafs;
+        dataStack.push({
+          angleStart: a1,
+          angleEnd: a2,
+          xpos: x,
+          ypos: y,
+          level: level + 1,
+          number: tree.getChild(node, i).number,
+        });
+      }
+    }
+    map.set(node, vertex);
+  }
+
+  return function (node: NodeRef): FunctionalVertex {
+    if (map.has(node)) {
+      return map.get(node) as FunctionalVertex; // must be here since we check it above
+    } else {
+      throw new Error("Node not found in layout -  has the tree changed");
+    }
+  };
+}
+
+//this function converts radians to degrees and adjusts degrees
+// so the text is not fliped
+export function textSafeDegrees(radians: number) {
+  const d = degrees(radians);
+  //trial and error  - must be a better way
+  if (d > 90 && d < 270) {
+    return (d - 180) / 2;
+  } else if (d > 0 && d < 88) {
+    return d / 2;
+  } else if (d < 360 && d > 272) {
+    return (360 + d) / 2;
+  } else {
+    return d;
+  }
+}
+export function normalizeAngle(theta: number) {
+  while (theta > 2 * Math.PI) {
+    theta -= 2 * Math.PI;
+  }
+  return theta;
+}
+
+export function degrees(theta: number) {
+  return (normalizeAngle(theta) * 180) / Math.PI;
+}

package/src/layouts/functional/rectangular-layout.ts

@@ -0,0 +1,71 @@
+import { mean } from "d3-array";
+import type { ImmutableTree, NodeRef } from "../../evo";
+import { postOrderIterator } from "../../evo";
+import type { NodeLabelType, FunctionalVertex } from "../types";
+import { layoutClass } from "../types";
+import { unNullify } from "../../utils";
+
+export function baseLayout(lc: layoutClass) {
+  function layout(tree: ImmutableTree): (node: NodeRef) => FunctionalVertex {
+    const map = new Map<NodeRef, FunctionalVertex>();
+
+    let currentY = 0;
+    for (const node of postOrderIterator(tree)) {
+      let protoVertex: { x: number; y: number };
+      const x = tree.getDivergence(node);
+      const leftLabel = tree.getChildCount(node) > 0;
+      const hasParent = !tree.isRoot(node);
+      const labelBelow =
+        tree.getChildCount(node) > 0 &&
+        (!hasParent || tree.getChild(tree.getParent(node), 0) !== node);
+
+      if (tree.isExternal(node)) {
+        protoVertex = { x, y: currentY };
+        currentY++;
+      } else {
+        const kidPositions = tree
+          .getChildren(node)
+          .map((child) =>
+            unNullify(
+              map.get(child),
+              `Internal Error: child not yet found in layout`,
+            ),
+          );
+        const y = unNullify(
+          mean(kidPositions, (d) => d.y),
+          `Error taking the mean of child positions`,
+        );
+        protoVertex = { x, y };
+      }
+      const vertex = {
+        ...protoVertex,
+        layoutClass: lc,
+        nodeLabel: {
+          alignmentBaseline: leftLabel
+            ? labelBelow
+              ? "bottom"
+              : "hanging"
+            : "middle", // todo calc on the fly
+          textAnchor: leftLabel ? "end" : "start",
+          dxFactor: leftLabel ? -1 : 1,
+          dyFactor: leftLabel ? (labelBelow ? -1 : 1) : 0,
+          rotation: 0,
+        } as NodeLabelType,
+      };
+      map.set(node, vertex);
+    }
+
+    return function (node: NodeRef): FunctionalVertex {
+      if (map.has(node)) {
+        return map.get(node) as FunctionalVertex; // check above so
+      } else {
+        console.log(node);
+        throw new Error("Node not found in layout -  has the tree changed");
+      }
+    };
+  }
+  return layout;
+}
+
+export const rectangularLayout = baseLayout(layoutClass.Rectangular);
+export const polarLayout = baseLayout(layoutClass.Polar);

package/src/layouts/index.ts

@@ -0,0 +1,3 @@
+export * from "./layout-interface";
+export * from "./functional";
+export * from "./types";