@figtreejs/core 0.0.1-alpha.0

package/src/components/hoc/with-clades.tsx

@@ -0,0 +1,47 @@
+/**
+ * An HOC that calculates the clades needed for clade shapes and
+ * passes them on to the shapes themselves
+ */
+
+import type { NodeRef } from "../../evo";
+import type { AttrsRecord, InternalInteractionType } from "../baubles/types";
+
+export type Clade = {
+  root: NodeRef;
+  leftMost: NodeRef;
+  rightMost: NodeRef;
+  mostDiverged: NodeRef;
+};
+
+export type CladeProps<A extends object> = {
+  clades: Clade[];
+  attrs?: AttrsRecord<A>;
+  interactions?: { [key: string]: InternalInteractionType }; // keyed by node id // check type
+  // shape:NodeShapes,
+  keyBy?: (n: NodeRef) => string;
+};
+export function withClades<T extends object>(
+  ShapeComponent: React.FC<T & { clade: Clade }>,
+): React.FC<CladeProps<T>> {
+  const withClades = (props: CladeProps<T>) => {
+    const { clades, keyBy = (n: NodeRef) => n._id, attrs = {} } = props;
+
+    return (
+      <g className={"node-layer"}>
+        {clades.map((clade) => {
+          const cladeAttrs = attrs[clade.root._id] ?? {};
+          return (
+            <ShapeComponent
+              key={keyBy(clade.root)}
+              clade={clade}
+              {...cladeAttrs}
+              // interactions={nodeInteractions}
+            />
+          );
+        })}
+      </g>
+    );
+  };
+  withClades.displayName = `withCladessArray(${ShapeComponent.displayName || ShapeComponent.name || "Component"})`;
+  return withClades;
+}

package/src/components/hoc/with-node.tsx

@@ -0,0 +1,183 @@
+import React, { useContext } from "react";
+import type { NodeRef } from "../../evo";
+import { ScaleContext } from "../../context/scale-context";
+import { layoutContext } from "../../context/layout-context";
+import { animatedContext } from "../../context/aminated-context";
+import { DimensionContext } from "../../context/dimension-context";
+import { layoutClass } from "../../layouts";
+import { defaultNodeLabelData } from "../../store/store";
+import type { PolarVertex } from "../../layouts/types";
+import { textSafeDegrees } from "../../store/polar-scale";
+import { unNullify } from "../../utils";
+
+//The goal here is now to take a shape components that accepts Attrs: number | string , x/y
+// and return a component that takes a node / layout/ scale and attrs:number|string | function
+
+type Injected = {
+  x: number;
+  y: number;
+  animated: boolean;
+};
+
+/**
+ *  This HOC takes a shape (possibly animated) that requires x,y values and calculated attributes and
+ * calculates those values from a node.
+ *
+ */
+
+export function withNode<T extends object>(
+  WrappedComponent: React.FC<T & Injected>,
+) {
+  type ExposedProps = T & { node: NodeRef };
+
+  const NodedComponent: React.FC<ExposedProps> = (props) => {
+    const scale = useContext(ScaleContext);
+    const layout = useContext(layoutContext);
+    const animated = useContext(animatedContext);
+
+    const { node, ...rest } = props;
+    const v = scale(layout(node));
+
+    return (
+      <WrappedComponent {...(rest as T)} x={v.x} y={v.y} animated={animated} />
+    );
+  };
+
+  NodedComponent.displayName = `withNode(${WrappedComponent.displayName || WrappedComponent.name || "Component"})`;
+
+  return NodedComponent;
+}
+
+/**
+ * An HOC that determines the x,y, rotation alignment base and text anchor of a label
+ * if a parent is passed in then the component renders a branch label
+ */
+export type LabelInjection = {
+  x: number;
+  y: number;
+  animated: boolean;
+  alignmentBaseline: React.ComponentProps<"text">["alignmentBaseline"];
+  rotation: number;
+  textAnchor: React.ComponentProps<"text">["textAnchor"];
+  d?: string;
+};
+export function withNodeLabel<T extends object>(
+  WrappedComponent: React.FC<T & LabelInjection>,
+) {
+  // parent for branch
+  type ExposedProps = T & {
+    node: NodeRef;
+    parent?: NodeRef;
+    aligned?: boolean;
+    gap?: number;
+  };
+
+  const NodedComponent: React.FC<ExposedProps> = (props) => {
+    const scale = useContext(ScaleContext);
+    const layout = useContext(layoutContext);
+    const animated = useContext(animatedContext);
+    const { domainX, layoutClass: layoutType } = useContext(DimensionContext);
+
+    const { node, parent, aligned, gap = 6, ...rest } = props;
+    const v = layout(node);
+    const scaledV = scale(v);
+
+    if (parent === undefined) {
+      // node label
+      const nodeLabel = scaledV.nodeLabel ?? defaultNodeLabelData;
+      const dx = nodeLabel.dxFactor * gap;
+      const dy = nodeLabel.dyFactor * gap;
+
+      const scaledMax = scale({ x: domainX[1], y: v.y });
+
+      const xpos = (aligned ? scaledMax.x : scaledV.x) + dx;
+      const ypos =
+        (aligned && layoutType === layoutClass.Polar
+          ? scaledMax.y
+          : scaledV.y) + dy;
+      const { alignmentBaseline, rotation, textAnchor } = nodeLabel;
+
+      const d = aligned
+        ? `M${scaledV.x} ${scaledV.y}L${xpos} ${ypos}`
+        : `M${scaledV.x} ${scaledV.y}L${scaledV.x} ${scaledV.y}`;
+      return (
+        <WrappedComponent
+          alignmentBaseline={alignmentBaseline}
+          rotation={rotation}
+          textAnchor={textAnchor}
+          d={d}
+          x={xpos}
+          y={ypos}
+          {...(rest as T)}
+          animated={animated}
+        />
+      );
+    } else {
+      const parentVertex = layout(parent);
+      const scaledPv = scale(parentVertex);
+      // todo fix this so we don't need all the casting etc.
+      const theta =
+        layoutType === layoutClass.Polar
+          ? unNullify(
+              (scaledV as PolarVertex).theta,
+              "The layout is polar but theta was not calculated for this node",
+            )
+          : 0;
+      const rotation =
+        layoutType === layoutClass.Polar ? textSafeDegrees(theta) : 0;
+      const step = scale({ x: parentVertex.x, y: v.y });
+      const { dx, dy } =
+        layoutType === layoutClass.Polar
+          ? getPolarBranchDs(theta, gap)
+          : { dx: 0, dy: -1 * gap };
+      const x =
+        (layoutType === layoutClass.Polar
+          ? (scaledV.x + step.x) / 2
+          : (scaledV.x + scaledPv.x) / 2) + dx;
+      const y =
+        (layoutType === layoutClass.Polar
+          ? (scaledV.y + step.y) / 2
+          : layoutType === layoutClass.Radial
+            ? (scaledV.y + scaledPv.y) / 2
+            : scaledV.y) + dy;
+
+      return (
+        <WrappedComponent
+          alignmentBaseline={"baseline"}
+          rotation={rotation}
+          textAnchor={"middle"}
+          x={x}
+          y={y}
+          {...(rest as T)}
+          animated={animated}
+        />
+      );
+    }
+  };
+
+  NodedComponent.displayName = `withNodeLabel(${WrappedComponent.displayName || WrappedComponent.name || "Component"})`;
+
+  return NodedComponent;
+}
+
+function getPolarBranchDs(theta: number, gap: number) {
+  //branch lable dx dy;
+  let branchDx, branchDy;
+  if (theta > 0 && theta < Math.PI / 2) {
+    //good
+    branchDx = Math.sin(Math.PI / 2 - theta) * gap;
+    branchDy = -Math.cos(Math.PI / 2 - theta) * gap;
+  } else if (theta > Math.PI / 2 && theta < Math.PI) {
+    //good
+    branchDx = -Math.cos(Math.PI / 2 - (Math.PI - theta)) * gap;
+    branchDy = -Math.sin(Math.PI / 2 - (Math.PI - theta)) * gap;
+  } else if (theta > Math.PI && theta < (3 * Math.PI) / 2) {
+    // good
+    branchDx = Math.cos(Math.PI / 2 - (theta - Math.PI)) * gap;
+    branchDy = -Math.sin(Math.PI / 2 - (theta - Math.PI)) * gap;
+  } else {
+    branchDx = -Math.cos(Math.PI / 2 - (2 * Math.PI - theta)) * gap;
+    branchDy = -Math.sin(Math.PI / 2 - (2 * Math.PI - theta)) * gap;
+  }
+  return { dx: branchDx, dy: branchDy };
+}

package/src/components/hoc/with-nodes.tsx

@@ -0,0 +1,45 @@
+import type { NodeRef } from "../../evo";
+import type { AttrsRecord, InternalInteractionType } from "../baubles/types";
+
+export type NodeProps<A extends object> = {
+  nodes: NodeRef[];
+  attrs?: AttrsRecord<A>;
+  interactions?: { [key: string]: InternalInteractionType }; // keyed by node id // check type
+  aligned?: boolean;
+  keyBy?: (n: NodeRef) => string;
+};
+
+//TODO key by not being passed down
+
+/**
+ * A component that
+ * The factory accepts the options above and returns a Bauble to be rendered by the figure.
+ */
+//TODO do interactions
+export function withNodes<T extends object>(
+  ShapeComponent: React.FC<T & { node: NodeRef }>,
+): React.FC<NodeProps<T>> {
+  const withNodes = (props: NodeProps<T>) => {
+    const { nodes, keyBy = (n: NodeRef) => n._id, attrs = {}, aligned } = props;
+
+    return (
+      <g className={"node-layer"}>
+        {nodes.map((node) => {
+          const nodeAttrs = attrs[node._id] ?? {};
+          // const nodeInteractions = interactions[node._id]?? {}
+          return (
+            <ShapeComponent
+              key={keyBy(node)}
+              node={node}
+              {...nodeAttrs}
+              aligned={aligned}
+              // interactions={nodeInteractions}
+            />
+          );
+        })}
+      </g>
+    );
+  };
+  withNodes.displayName = `withNodesArray(${ShapeComponent.displayName || ShapeComponent.name || "Component"})`;
+  return withNodes;
+}

package/src/components/index.ts

@@ -0,0 +1,4 @@
+export * from "./baubles";
+export * from "./figtree";
+// export * from "./Tanglegram"
+export * from "./decorations";

package/src/context/aminated-context.ts

@@ -0,0 +1,3 @@
+import { createContext } from "react";
+
+export const animatedContext = createContext(false);

package/src/context/dimension-context.ts

@@ -0,0 +1,22 @@
+import { createContext } from "react";
+import type { dimensionType } from "../components/figtree/figtree-types";
+import { layoutClass } from "../layouts";
+
+const defaultDimension: dimensionType = {
+  canvasWidth: 0,
+  canvasHeight: 0,
+  domainX: [0, 1],
+  domainY: [0, 1],
+  layoutClass: layoutClass.Rectangular,
+  invert: false,
+  pollard: 0,
+  minRadius: 0,
+  fishEye: {
+    x: 0,
+    y: 0,
+    scale: 0,
+  },
+  rootAngle: 0,
+  angleRange: 0,
+};
+export const DimensionContext = createContext(defaultDimension);

package/src/context/layout-context.ts

@@ -0,0 +1,20 @@
+import { createContext } from "react";
+import type { layoutType } from "../store/store";
+import { layoutClass } from "../layouts";
+
+const defaultLayout: layoutType = () => {
+  return {
+    x: 0,
+    y: 0,
+    layoutClass: layoutClass.Rectangular,
+    nodeLabel: {
+      // todo move this to a helper function
+      alignmentBaseline: "middle",
+      textAnchor: "end",
+      dxFactor: 0,
+      dyFactor: 0,
+      rotation: 0,
+    },
+  };
+};
+export const layoutContext = createContext(defaultLayout);

package/src/context/scale-context.ts

@@ -0,0 +1,12 @@
+import { createContext } from "react";
+import type { scaleType } from "../store/store";
+import type { simpleVertex } from "../layouts/types";
+
+const defaultScale: scaleType = <T extends simpleVertex>(vertex: T) => {
+  return {
+    ...vertex,
+    x: 0,
+    y: 0,
+  };
+};
+export const ScaleContext = createContext(defaultScale);

package/src/evo/index.ts

@@ -0,0 +1 @@
+export * from "./tree";

package/src/evo/tree/index.ts

@@ -0,0 +1,5 @@
+export * from "./normalized-tree";
+export * from "./tree-types";
+export * from "./parsers/stream-reader";
+export * from "./traversals";
+export * from "./taxa";

package/src/evo/tree/normalized-tree/immutable-tree-helpers.ts

@@ -0,0 +1,136 @@
+/**
+ * These function help access tree data while
+ * handling missing data.
+ *
+ * They cannot be private functions on the method because
+ * those can't be called by immer proxies.
+ */
+
+import type { Maybe, Undefinable } from "@figtreejs/maybe/maybe";
+import { MaybeType, Nothing, Some } from "@figtreejs/maybe/maybe";
+import type { Annotation, NodeRef } from "../tree-types";
+import type { ImmutableTree, nodeIndex, Node } from "./immutable-tree";
+import type { Taxon } from "../taxa";
+import {
+  maybeGetNameFromIndex,
+  maybeGetTaxonByName,
+} from "../taxa/helper-functions";
+
+/**
+ *
+ * A private getting for retrieving a NodeRef from a number
+ */
+export function maybeGetNodeFromNumber(
+  tree: ImmutableTree,
+  i: number,
+): Maybe<NodeRef> {
+  const n = tree._data.nodes.allNodes[i] as Undefinable<NodeRef>;
+  if (n === undefined) {
+    return Nothing();
+  } else {
+    return Some(n);
+  }
+}
+
+export function maybeGetNode(
+  tree: ImmutableTree,
+  i: nodeIndex,
+): Maybe<NodeRef> {
+  if (typeof i === "number") {
+    return maybeGetNodeFromNumber(tree, i);
+  } else if (i instanceof Object) {
+    return maybeGetNodeByTaxon(tree, i);
+  } else if (typeof i === "string") {
+    const taxon = maybeGetTaxonByName(tree.taxonSet._data, i);
+    if (taxon.type === MaybeType.Some) {
+      return maybeGetNodeByTaxon(tree, taxon.value);
+    } else {
+      return maybeGetNodeByLabel(tree, i);
+    }
+  }
+  return Nothing();
+}
+
+export function maybeGetNodeByTaxon(
+  tree: ImmutableTree,
+  taxon: Taxon,
+): Maybe<NodeRef> {
+  const n = tree._data.nodes.byTaxon[taxon.number] as Undefinable<number>;
+  if (n === undefined) {
+    return Nothing();
+  } else {
+    return maybeGetNode(tree, n);
+  }
+}
+
+// export function maybeGetTaxonByName(tree:ImmutableTree, name:string):Maybe<Taxon>{
+//       const t =  tree.taxonSet.getTaxonByName(name)
+//       if(t===undefined){
+//         return Nothing()
+//       }else{
+//         return Some(t)
+//       }
+//   }
+
+export function maybeGetNodeByLabel(
+  tree: ImmutableTree,
+  label: string,
+): Maybe<NodeRef> {
+  const index = tree._data.nodes.byLabel[label] as Undefinable<number>;
+  if (index === undefined) {
+    return Nothing();
+  }
+  return maybeGetNodeFromNumber(tree, index);
+}
+
+export function maybeGetAnnotation(
+  tree: ImmutableTree,
+  node: NodeRef,
+  name: string,
+): Maybe<Annotation> {
+  const a = (tree.getNode(node.number) as Node).annotations[
+    name
+  ] as Undefinable<Annotation>;
+  if (a === undefined) {
+    return Nothing();
+  } else {
+    return Some(a);
+  }
+}
+
+export function maybeGetTaxonFromNode(
+  tree: ImmutableTree,
+  node: NodeRef,
+): Maybe<Taxon> {
+  const taxaIndex = tree._data.nodeToTaxon[node.number] as Undefinable<number>;
+  if (taxaIndex === undefined) {
+    return Nothing();
+  }
+  return maybeGetTaxon(tree, taxaIndex);
+}
+
+export function maybeGetTaxon(
+  tree: ImmutableTree,
+  id: number | NodeRef | string,
+): Maybe<Taxon> {
+  if (typeof id === "number") {
+    return maybeGetTaxonByName(
+      tree.taxonSet._data,
+      maybeGetNameFromIndex(tree.taxonSet._data, id),
+    );
+  } else if (typeof id === "string") {
+    return maybeGetTaxonByName(tree.taxonSet._data, id);
+  } else {
+    return maybeGetTaxonFromNode(tree, id);
+  }
+}
+
+export function maybeGetParent(
+  tree: ImmutableTree,
+  node: NodeRef,
+): Maybe<NodeRef> {
+  const n = tree._data.nodes.allNodes[node.number] as Undefinable<Node>;
+  if (n === undefined) return Nothing();
+  const parentId = n.parent;
+  return parentId === undefined ? Nothing() : maybeGetNode(tree, parentId);
+}

package/src/evo/tree/normalized-tree/immutable-tree.test.ts

@@ -0,0 +1,158 @@
+//TODO test immutable tree include tests that check nodes to roots update as well.
+
+import { notNull, u } from "../../../utils";
+import { ImmutableTree } from "./immutable-tree";
+import { describe, it, expect } from "vitest";
+
+describe("ImmutableTree", () => {
+  it("simpleTree", function () {
+    const tree = new ImmutableTree();
+    const added = tree.addNodes();
+    const tree1 = added.tree;
+    expect(tree.getNodeCount()).toEqual(1);
+    expect(tree1.getNodeCount()).toEqual(2);
+    expect(tree1).not.toEqual(tree);
+  });
+  //Add child used getNode and updates both node and child.
+  it("build tree and check parent", function () {
+    const prototree = new ImmutableTree();
+    const {
+      tree: tree,
+      nodes: [child, child2],
+    } = prototree.addNodes(2);
+    notNull(child, "can not be null");
+    notNull(child2, "can not be null");
+    const parent = tree.getNode(0);
+    const tree1 = tree.addChild(parent, child).addChild(parent, child2);
+
+    expect(tree1).not.toEqual(tree);
+    expect(tree1.getChildCount(parent)).toEqual(2);
+
+    expect(tree1.getParent(child)).not.toEqual(parent); //bc parent changed when added child
+    expect(tree1.getParent(child)).toEqual(tree1.getNode(0)); //bc parent changed when added child
+    expect(() => tree.getParent(child)).toThrow("No parent for node 1");
+    expect(tree1.getChild(parent, 0)).toEqual(tree1.getNode(1));
+    expect(tree1.getChild(parent, 0)).not.toEqual(child); // this child has no parent!
+  });
+  it("Change branchlength", function () {
+    const prototree = new ImmutableTree();
+
+    const {
+      tree: tree,
+      nodes: [parent, child, child2],
+    } = prototree.addNodes(3);
+    notNull(child, "can not be null");
+    notNull(child2, "can not be null");
+    notNull(parent, "can not be null");
+
+    const tree1 = tree.addChild(parent, child).addChild(parent, child2);
+
+    const tree2 = tree1.setLength(child, 0.5);
+    expect(tree2).not.toEqual(tree1);
+    // expect(tree1.getNode(0)).not.toBe(tree2.getNode(0));
+    // expect(tree1.getParent(child)).not.toBe(tree2.getParent(child));
+  });
+  it("change height", function () {
+    const tree = ImmutableTree.fromNewick("((A:1,B:1):1,C:2);");
+    const A = tree.getTaxonByName("A");
+    const B = tree.getTaxonByName("B");
+    const nodeA = tree.getNodeByTaxon(A);
+
+    expect(tree.getHeight(nodeA)).toBe(0);
+    const tree1 = tree.setHeight(nodeA, 0.5);
+
+    const nodeA1 = tree1.getNodeByTaxon(A);
+    expect(tree1.getHeight(nodeA1)).toBe(0.5);
+
+    expect(
+      tree1.getHeight(u(tree1.getNodeByTaxon(u(tree.getTaxonByName("B"))))),
+    ).toBe(0);
+    expect(tree1.getLength(nodeA1)).toBe(0.5);
+
+    expect(tree1.getDivergence(nodeA1)).toBe(1.5);
+    expect(tree1.getDivergence(u(tree1.getNodeByTaxon(B)))).toBe(2);
+  });
+  it("order", function () {
+    const newickString = `((((((virus1:0.1,virus2:0.12):0.08,(virus3:0.011,virus4:0.0087):0.15):0.03,virus5:0.21):0.2,(virus6:0.45,virus7:0.4):0.02):0.1,virus8:0.4):0.1,(virus9:0.04,virus10:0.03):0.6);`;
+
+    const tree = ImmutableTree.fromNewick(newickString, {
+      parseAnnotations: false,
+    });
+    const orderedTree = tree.orderNodesByDensity(true);
+
+    expect(orderedTree.toNewick()).toBe(
+      `((virus9:0.04,virus10:0.03):0.6,(virus8:0.4,((virus6:0.45,virus7:0.4):0.02,(virus5:0.21,((virus1:0.1,virus2:0.12):0.08,(virus3:0.011,virus4:0.0087):0.15):0.03):0.2):0.1):0.1);`,
+    );
+  });
+
+  it("bigger reroot - caused issues once", function () {
+    const newickString = `((((((virus1:0.1,virus2:0.12):0.08,(virus3:0.011,virus4:0.0087):0.15):0.03,virus5:0.21):0.2,(virus6:0.45,virus7:0.4):0.02):0.1,virus8:0.4):0.1,(virus9:0.04,virus10:0.03):0.6);`;
+
+    const tree = ImmutableTree.fromNewick(newickString);
+    const virus3 = tree.getTaxonByName("virus3");
+    const tree1 = tree.reroot(
+      u(tree.getParent(u(tree.getNodeByTaxon(virus3)))),
+      0.5,
+    );
+    expect(tree1.toNewick()).toBe(
+      "(((virus1:0.1,virus2:0.12):0.08,(virus5:0.21,((virus6:0.45,virus7:0.4):0.02,(virus8:0.4,(virus9:0.04,virus10:0.03):0.7):0.1):0.2):0.03):0.075,(virus3:0.011,virus4:0.0087):0.075);",
+    );
+  });
+
+  it("rotate", function () {
+    const tree = ImmutableTree.fromNewick("((A:1,B:1):1,C:2);");
+    const A = tree.getTaxonByName("A");
+    const B = tree.getTaxonByName("B");
+    const node = u(tree.getParent(u(tree.getNodeByTaxon(A))));
+    const child1 = tree.getChild(node, 0);
+    const rotatedTree = tree.rotate(node);
+    const child2 = rotatedTree.getChild(node, 0);
+
+    expect(rotatedTree.getTaxonFromNode(child2)).toBe(B);
+    expect(tree.getTaxonFromNode(child1)).toBe(A);
+  });
+  it("set height test", function () {
+    const tree = ImmutableTree.fromNewick("((A:1,B:1):1,C:2);");
+    const A = tree.getTaxonByName("A");
+    const B = tree.getTaxonByName("B");
+    const node = u(tree.getParent(u(tree.getNodeByTaxon(A)))); // current height is 1.
+    // const child1 = tree.getChild(node,0)!;
+    // const child2 = tree.getChild(node,1)!;
+    expect(tree.getHeight(node)).toBe(1);
+    const newTree = tree.setHeight(node, 0.5);
+    expect(newTree.getLength(node)).toBe(1.5);
+    expect(newTree.getHeight(node)).toBe(0.5);
+
+    expect(newTree.getLength(u(tree.getNodeByTaxon(A)))).toBe(0.5);
+    expect(newTree.getLength(u(tree.getNodeByTaxon(B)))).toBe(0.5);
+  });
+  it("set height test - negative length", function () {
+    const tree = ImmutableTree.fromNewick("((A:1,B:1):1,C:2);");
+    const A = tree.getTaxonByName("A");
+
+    const node = tree.getParent(u(tree.getNodeByTaxon(A))); // current height is 1.
+    const root = tree.getRoot();
+
+    const newTree = tree.setHeight(root, 0.5);
+    expect(newTree.getLength(node)).toBe(-0.5);
+    expect(newTree.getHeight(node)).toBe(1.0);
+
+    const Cnode = tree.getNode("C");
+    expect(newTree.getLength(Cnode)).toBe(0.5);
+    // expect(newTree.getLength(tree.getNodeByTaxon(B)!)).toBe(0.5);
+  });
+});
+describe("testing annotating", () => {
+  it("basic annotation", () => {
+    const tree = ImmutableTree.fromNewick("((A:1,B:1):1,C:2);");
+    const A = tree.getNode("A");
+    const annotatedTree = tree.annotateNode(A, "state", "WA");
+    annotatedTree.getAnnotation(A, "state");
+  });
+  it("basic annotation multiple keys", () => {
+    const tree = ImmutableTree.fromNewick("((A:1,B:1):1,C:2);");
+    const A = tree.getNode("A");
+    const annotatedTree = tree.annotateNode(A, { state: "WA" });
+    annotatedTree.getAnnotation(A, "state");
+  });
+});