col-browser 2.0.1 → 2.2.0

package/es/tree.js

@@ -0,0 +1,823 @@
+var J = Object.defineProperty;
+var Q = (C, y, e) => y in C ? J(C, y, { enumerable: !0, configurable: !0, writable: !0, value: e }) : C[y] = e;
+var c = (C, y, e) => Q(C, typeof y != "symbol" ? y + "" : y, e);
+import { a as X } from "./chunks/withDatasetKey-BgMY05XE.js";
+import { c as S, w as Y } from "./chunks/config-BPRXv9x8.js";
+import { j as t } from "./chunks/jsx-runtime-BzflLqGi.js";
+import j, { createContext as ee } from "react";
+import { Popover as te, Divider as se, Spin as R, Tag as ae, Alert as b, Skeleton as oe, Tree as ie, Button as ne, Row as re, Col as v, Checkbox as $ } from "antd";
+import { sortBy as N, get as m, isUndefined as I, flatten as le, isArray as A } from "lodash-es";
+import { L, c as D, R as U, s as de, b as he } from "./chunks/router-CssZk5qZ.js";
+import T from "dataloader";
+import { c as W, b as H, g as ce } from "./chunks/dataset-DvQG4NjA.js";
+import { M as pe } from "./chunks/MergedDataBadge-DsTsn5Xu.js";
+import { E as ue } from "./chunks/ErrorMsg-K8k5PPTp.js";
+import { g as fe } from "./chunks/sector-BnVzMnMO.js";
+import { C as F, N as xe } from "./chunks/DatasetCitation-bkPmDDYB.js";
+import { r as O, w as M } from "./chunks/storage-BgdCo9fV.js";
+const w = ee({
+  datasetLoader: null,
+  publisherLoader: null
+}), B = (C) => ({
+  datasetLoader: new T((y) => H(y, C)),
+  publisherLoader: new T(
+    (y) => W(y, C)
+  )
+});
+class V extends j.Component {
+  constructor(e) {
+    super(e);
+    // Returns the shared cache from TreeCacheContext if available, or a
+    // throwaway local DataLoader so the popover still works even if context
+    // doesn't reach this instance (which used to leave the spinner stuck
+    // because getData early-returned with no loading state set).
+    c(this, "getDatasetLoader", () => {
+      var s;
+      const { datasetKey: e } = this.props;
+      return (s = this.context) != null && s.datasetLoader ? this.context.datasetLoader : (this._localDatasetLoader || (this._localDatasetLoader = new T(
+        (o) => H(o, e)
+      )), this._localDatasetLoader);
+    });
+    c(this, "getPublisherLoader", () => {
+      var s;
+      const { datasetKey: e } = this.props;
+      return (s = this.context) != null && s.publisherLoader ? this.context.publisherLoader : (this._localPublisherLoader || (this._localPublisherLoader = new T(
+        (o) => W(o, e)
+      )), this._localPublisherLoader);
+    });
+    c(this, "componentDidMount", () => {
+      const { sourceDatasetKeys: e } = this.props;
+      e && e.length < 4 && this.setState({ showInNode: !0 }, this.getData);
+    });
+    c(this, "getData", () => {
+      const { sourceDatasetKeys: e } = this.props;
+      if (!(e != null && e.length)) return;
+      this.setState({ loading: !0 });
+      const s = this.getDatasetLoader();
+      Promise.all(
+        e.map((o) => s.load(o).catch(() => null))
+      ).then((o) => {
+        this.setState({ data: N(o, ["alias"]), loading: !1 });
+      }).catch(() => {
+        this.setState({ data: [], loading: !1 });
+      });
+    });
+    c(this, "getPublisherData", () => {
+      const { publisherDatasetKeys: e } = this.props;
+      if (!e) return;
+      const s = this.getPublisherLoader();
+      Promise.all(
+        Object.keys(e).map(
+          (o) => s.load(o).then((r) => ({
+            ...r,
+            datasets: e[o]
+          })).catch(() => null)
+        )
+      ).then((o) => {
+        this.setState({ publishers: N(o.filter(Boolean), ["alias"]) });
+      }).catch(() => {
+        this.setState({ publishers: [] });
+      });
+    });
+    c(this, "render", () => {
+      const { data: e, showInNode: s, popOverVisible: o, loading: r } = this.state, { taxon: l, datasetKey: h } = this.props, n = { color: "orange", fontSize: "11px" }, u = (a) => `${S.clbPortal}/dataset/${h}/publisher/${a}`;
+      return s ? e.filter((a) => !!a).map((a, d) => /* @__PURE__ */ t.jsx(
+        L,
+        {
+          to: "source",
+          args: a.key,
+          className: "col-tree-data-source",
+          style: n,
+          children: (d ? ", " : "") + (a.alias || a.key)
+        },
+        a.key
+      )) : /* @__PURE__ */ t.jsx("div", { style: { display: "inline" }, id: `taxon_sources_${l.id}`, children: /* @__PURE__ */ t.jsx(
+        te,
+        {
+          getPopupContainer: () => document.getElementById(`taxon_sources_${l.id}`),
+          content: r || e.length === 0 ? /* @__PURE__ */ t.jsx(
+            "div",
+            {
+              style: { minWidth: "200px", textAlign: "center", padding: "8px 0" },
+              children: /* @__PURE__ */ t.jsx(R, { size: "small" })
+            }
+          ) : /* @__PURE__ */ t.jsxs("div", { style: { maxWidth: "500px" }, children: [
+            e.length > 0 && /* @__PURE__ */ t.jsx("div", { children: e.filter((a) => !!a).map((a, d) => /* @__PURE__ */ t.jsx(
+              L,
+              {
+                to: "source",
+                args: a.key,
+                className: "col-tree-data-source",
+                style: n,
+                children: (d ? ", " : "") + (a.alias || a.key)
+              },
+              a.key
+            )) }),
+            this.state.publishers && this.state.publishers.length > 0 && /* @__PURE__ */ t.jsxs("div", { style: { marginTop: "12px" }, children: [
+              /* @__PURE__ */ t.jsx("strong", { children: "Publishers" }),
+              /* @__PURE__ */ t.jsx("div", { children: this.state.publishers.filter((a) => !!a).map((a, d) => {
+                var f;
+                return /* @__PURE__ */ t.jsxs(
+                  "a",
+                  {
+                    href: u(a.id),
+                    target: "_blank",
+                    rel: "noopener noreferrer",
+                    style: n,
+                    children: [
+                      (d ? ", " : "") + (a.alias || a.id),
+                      (f = a.datasets) != null && f.length ? ` (${a.datasets.length.toLocaleString("en-GB")})` : ""
+                    ]
+                  },
+                  a.id
+                );
+              }) })
+            ] })
+          ] }),
+          title: /* @__PURE__ */ t.jsxs("div", { style: { padding: "4px 0" }, children: [
+            /* @__PURE__ */ t.jsx("span", { style: { fontWeight: 500 }, children: "Sources for " }),
+            /* @__PURE__ */ t.jsx("em", { children: l == null ? void 0 : l.name }),
+            /* @__PURE__ */ t.jsx(se, { style: { margin: "8px 0 0" } })
+          ] }),
+          open: o,
+          onOpenChange: (a) => this.setState({ popOverVisible: a }, () => {
+            a && this.state.data.length === 0 && this.getData(), a && this.props.publisherDatasetKeys && !this.state.publishers && this.getPublisherData();
+          }),
+          trigger: "click",
+          placement: "rightTop",
+          children: /* @__PURE__ */ t.jsx(
+            "a",
+            {
+              className: "col-tree-data-source",
+              role: "button",
+              tabIndex: 0,
+              style: { cursor: "pointer", color: "orange", fontSize: "11px" },
+              onClick: (a) => a.preventDefault(),
+              children: "Multiple sources"
+            }
+          )
+        }
+      ) });
+    });
+    this.state = {
+      data: [],
+      showInNode: !1,
+      loading: !1
+    };
+  }
+}
+c(V, "contextType", w);
+const z = j.createContext();
+class k extends j.Component {
+  constructor(e) {
+    super(e);
+    c(this, "rankIsAboveSpecies", (e) => this.props.rank.indexOf(e) < this.props.rank.indexOf("species"));
+    c(this, "render", () => {
+      const {
+        taxon: e,
+        taxon: { sector: s, sourceDatasetKeys: o, publisherDatasetKeys: r },
+        datasetKey: l
+      } = this.props, h = m(s, "dataset"), n = (o || []).filter((a) => (s == null ? void 0 : s.subjectDatasetKey) !== a).length > 0;
+      e.estimate && e.estimates && e.estimates.find((a) => a.estimate === e.estimate);
+      const u = typeof e.id == "string" && e.id.indexOf("incertae-sedis") > -1;
+      return /* @__PURE__ */ t.jsx(z.Consumer, { children: ({ showInfo: a }) => /* @__PURE__ */ t.jsxs("div", { id: e.id, children: [
+        /* @__PURE__ */ t.jsxs("span", { children: [
+          /* @__PURE__ */ t.jsxs("span", { className: "tree-node-rank", children: [
+            e.rank,
+            ": "
+          ] }),
+          u ? /* @__PURE__ */ t.jsx("span", { dangerouslySetInnerHTML: { __html: e.labelHtml } }) : /* @__PURE__ */ t.jsx(L, { to: "taxon", args: e.id, children: /* @__PURE__ */ t.jsx("span", { dangerouslySetInnerHTML: { __html: e.labelHtml } }) }),
+          (e == null ? void 0 : e.merged) && /* @__PURE__ */ t.jsx(pe, { style: { marginLeft: "4px" }, datasetKey: e == null ? void 0 : e.datasetKey, verbatimSourceKey: e == null ? void 0 : e.verbatimSourceKey })
+        ] }),
+        a && e.status === "provisionally accepted" && /* @__PURE__ */ t.jsxs(j.Fragment, { children: [
+          " • ",
+          /* @__PURE__ */ t.jsx(ae, { color: "warning", style: { marginRight: 0 }, children: "prov." })
+        ] }),
+        !I(e.count) && this.rankIsAboveSpecies(e == null ? void 0 : e.rank) && /* @__PURE__ */ t.jsxs("span", { children: [
+          " ",
+          "• ",
+          Number(e.count).toLocaleString(),
+          " ",
+          a && !I(e.speciesEstimate) && /* @__PURE__ */ t.jsxs("span", { children: [
+            " ",
+            "of",
+            " ",
+            Number(
+              e.speciesEstimate
+            ).toLocaleString(),
+            " ",
+            "est.",
+            " "
+          ] }),
+          "spp."
+        ] }),
+        a && s && /* @__PURE__ */ t.jsxs("span", { children: [
+          /* @__PURE__ */ t.jsx("span", { children: " • " }),
+          /* @__PURE__ */ t.jsxs(
+            L,
+            {
+              to: "source",
+              args: s.subjectDatasetKey,
+              style: n ? { fontWeight: "bold" } : null,
+              className: "col-tree-data-source",
+              children: [
+                m(h, "alias") || s.subjectDatasetKey,
+                n && ", "
+              ]
+            }
+          )
+        ] }),
+        a && n && /* @__PURE__ */ t.jsxs(j.Fragment, { children: [
+          " ",
+          /* @__PURE__ */ t.jsx(
+            V,
+            {
+              sourceDatasetKeys: o,
+              publisherDatasetKeys: r,
+              taxon: e,
+              datasetKey: l
+            }
+          )
+        ] })
+      ] }) });
+    });
+    this.state = {
+      style: {},
+      provisional: this.props.taxon.status === "provisionally accepted",
+      loading: !1
+    };
+  }
+}
+const K = 1e3;
+class ge extends j.Component {
+  constructor(e) {
+    super(e);
+    c(this, "onClick", () => {
+      this.setState(
+        { loading: !0 },
+        () => this.props.onClick().then(() => this.setState({ loading: !1 }))
+      );
+    });
+    c(this, "render", () => {
+      const { loading: e } = this.state;
+      return /* @__PURE__ */ t.jsxs(j.Fragment, { children: [
+        e && /* @__PURE__ */ t.jsx(R, {}),
+        !e && /* @__PURE__ */ t.jsx("a", { onClick: this.onClick, children: /* @__PURE__ */ t.jsx("strong", { children: "Load more..." }) })
+      ] });
+    });
+    this.state = { loading: !1 };
+  }
+}
+class G extends j.Component {
+  constructor(e) {
+    super(e);
+    c(this, "componentDidMount", () => {
+      const { datasetKey: e } = this.props;
+      this.loadRoot(), this.sectorLoader = new T(
+        (o) => fe(o, e)
+      ), this.getRank();
+      const { treeRef: s } = this.props;
+      s(this);
+    });
+    c(this, "componentDidUpdate", (e) => {
+      (e.defaultExpandKey !== this.props.defaultExpandKey || e.hideExtinct !== this.props.hideExtinct || e.insertPlaceholder !== this.props.insertPlaceholder) && this.reloadRoot();
+    });
+    c(this, "getRank", () => {
+      D(`${S.dataApi}vocab/rank`).then(
+        (e) => this.setState({ rank: e.data.map((s) => s.name) })
+      );
+    });
+    c(this, "reloadRoot", () => this.setState(
+      {
+        rootLoading: !0,
+        treeData: [],
+        loadedKeys: [],
+        rootTotal: 0,
+        error: null,
+        nodeNotFoundErr: null
+      },
+      this.loadRoot
+    ));
+    c(this, "loadRoot", async () => {
+      const {
+        showSourceTaxon: e,
+        datasetKey: s,
+        hideExtinct: o,
+        insertPlaceholder: r,
+        type: l,
+        expandedTaxonKey: h
+      } = this.props, n = h, { defaultTaxonKey: u } = this.props;
+      return this.setState({ rootLoading: !0, treeData: [] }), D(
+        `${S.dataApi}dataset/${s}/tree?projectKey=${s}${l ? "&type=" + l : ""}&limit=${K}&offset=${this.state.treeData.length}${o ? "&extinct=false&extinct=" : ""}${r ? "&insertPlaceholder=true" : ""}`
+      ).then(this.decorateWithSectorsAndDataset).then((a) => {
+        const d = a.data.result || [], f = a.data.total, x = d.map((p) => {
+          let i = {
+            taxon: p,
+            key: p.id,
+            datasetKey: s,
+            childCount: p.childCount,
+            isLeaf: p.childCount === 0,
+            childOffset: 0
+          };
+          return i.title = /* @__PURE__ */ t.jsx(
+            k,
+            {
+              taxon: p,
+              datasetKey: s,
+              showSourceTaxon: e,
+              reloadChildren: () => this.fetchChildPage(i, !0),
+              rank: this.state.rank
+            }
+          ), i.ref = i, i;
+        });
+        this.setState(
+          {
+            rootTotal: f,
+            rootLoading: !1,
+            treeData: [...this.state.treeData, ...x],
+            expandedKeys: x.length < 10 ? x.map((p) => p.taxon.id).filter((p) => p === "CS5HF") : [],
+            error: null
+          },
+          () => {
+            if (n)
+              return this.expandToTaxon(n);
+            if (u)
+              return this.expandToTaxon(u);
+          }
+        ), x.length === 1 && this.fetchChildPage(x[x.length - 1]);
+      }).catch((a) => {
+        this.setState({
+          treeData: [],
+          rootLoading: !1,
+          expandedKeys: [],
+          error: a
+        });
+      });
+    });
+    c(this, "expandToTaxon", async (e) => {
+      const {
+        showSourceTaxon: s,
+        datasetKey: o,
+        hideExtinct: r,
+        type: l
+      } = this.props;
+      this.setState({
+        rootLoading: !0
+        /* , treeData: [] */
+      });
+      const { data: h } = await D(
+        `${S.dataApi}dataset/${o}/tree/${e}?projectKey=${o}&insertPlaceholder=true${l ? "&type=" + l : ""}${r ? "&extinct=false" : ""}`
+      ).then(
+        (p) => this.decorateWithSectorsAndDataset({
+          data: { result: p.data }
+        }).then(() => p)
+      );
+      if (h.length === 0)
+        return this.setState(
+          {
+            error: {
+              message: `No classification found for Taxon ID: ${e}`
+            }
+          },
+          this.loadRoot
+        );
+      const n = h[h.length - 1];
+      let u = {
+        taxon: n,
+        key: n.id,
+        datasetKey: o,
+        childCount: n.childCount,
+        isLeaf: n.childCount === 0,
+        childOffset: 0
+      };
+      u.title = /* @__PURE__ */ t.jsx(
+        k,
+        {
+          taxon: n,
+          datasetKey: o,
+          showSourceTaxon: s,
+          rank: this.state.rank,
+          reloadChildren: () => this.fetchChildPage(u, !0)
+        }
+      ), u.ref = u;
+      const a = u;
+      for (let p = h.length - 2; p >= 0; p--) {
+        const i = h[p], g = {
+          taxon: i,
+          key: i.id,
+          datasetKey: o,
+          childCount: i.childCount,
+          isLeaf: i.childCount === 0,
+          childOffset: 0
+        };
+        g.ref = g, g.title = /* @__PURE__ */ t.jsx(
+          k,
+          {
+            taxon: i,
+            datasetKey: o,
+            showSourceTaxon: s,
+            rank: this.state.rank,
+            reloadChildren: () => this.fetchChildPage(g, !0)
+          }
+        ), u.children = [g], u = g;
+      }
+      const { treeData: d } = this.state;
+      var f = d.findIndex((p) => p.key == a.key);
+      d[f] = a;
+      const x = [...h.map((p) => p.id).reverse()];
+      this.setState(
+        { treeData: d },
+        () => this.reloadLoadedKeys(x, e)
+      );
+    });
+    c(this, "fetchChildPage", async (e, s, o) => {
+      const {
+        showSourceTaxon: r,
+        datasetKey: l,
+        hideExtinct: h,
+        insertPlaceholder: n,
+        type: u
+      } = this.props, { treeData: a } = this.state;
+      m(e, "childCount");
+      const d = K, f = m(e, "childOffset"), x = await D(
+        `${S.dataApi}dataset/${l}/tree/${e.taxon.id}/children?limit=${d}&offset=${f}&projectKey=${l}${u ? "&type=" + u : ""}${h ? "&extinct=false" : ""}${n ? "&insertPlaceholder=true" : ""}`
+      );
+      await this.decorateWithSectorsAndDataset(x);
+      const p = x.data.result ? x.data.result.map((i) => {
+        let g = {
+          taxon: i,
+          key: i.id,
+          datasetKey: l,
+          childCount: i.childCount,
+          isLeaf: i.childCount === 0,
+          childOffset: 0,
+          parent: e,
+          name: i.name
+        };
+        return g.title = /* @__PURE__ */ t.jsx(
+          k,
+          {
+            taxon: i,
+            datasetKey: l,
+            showSourceTaxon: r,
+            rank: this.state.rank,
+            reloadChildren: () => this.fetchChildPage(g, !0)
+          }
+        ), g.ref = g, g;
+      }) : [];
+      if (e.children = e.children && f !== 0 && !s ? [...e.children, ...p] : p, x.data.last && e.childCount > e.children.length && (e.childCount = e.children.length), !x.data.last) {
+        const i = () => (e.childOffset += K, e.children[e.children.length - 1].key === "__loadMoreBTN__" && (e.children = e.children.slice(0, -1)), this.fetchChildPage(e, !1));
+        e.children = [
+          ...e.children,
+          {
+            title: /* @__PURE__ */ t.jsx(
+              ge,
+              {
+                onClick: i
+              },
+              "__loadMoreBTN__"
+            ),
+            key: "__loadMoreBTN__",
+            childCount: 0,
+            isLeaf: !0
+          }
+        ];
+      }
+      o || this.setState({
+        treeData: [...a],
+        loadedKeys: [.../* @__PURE__ */ new Set([...this.state.loadedKeys, e.key])]
+      });
+    });
+    c(this, "decorateWithSectorsAndDataset", (e) => e.data.result ? Promise.all(
+      e.data.result.filter((s) => !!s.sectorDatasetKey).map(
+        (s) => this.datasetLoader.load(s.sectorDatasetKey).then(
+          (o) => s.sector = {
+            id: s.sectorKey,
+            subjectDatasetKey: s.sectorDatasetKey,
+            dataset: o
+          }
+        )
+      )
+    ).then(() => e) : e);
+    c(this, "onLoadData", (e, s = !1) => (s && (e.childOffset = 0), this.fetchChildPage(e.ref, s)));
+    c(this, "findNode", (e, s) => {
+      let o = null;
+      if (o = s.find((r) => m(r, "taxon.id") === e), o)
+        return o;
+      {
+        const r = s.map((h) => m(h, "children") || []), l = le(r);
+        return l.length === 0 ? null : this.findNode(e, l);
+      }
+    });
+    c(this, "pageThroughChildrenUntilTaxonFound", async (e, s) => {
+      let o;
+      for (; !o && e.children.length < e.childCount; )
+        e.childOffset += K, e.children[e.children.length - 1].key === "__loadMoreBTN__" && (e.children = e.children.slice(0, -1)), await this.fetchChildPage(e, !1, !0), o = this.findNode(s, e.children);
+      return o || (o = e.children.find(
+        (r) => m(r, "taxon.id") ? r.taxon.id.indexOf("incertae-sedis") > -1 : !1
+      )), o;
+    });
+    c(this, "reloadLoadedKeys", async (e, s, o = !0) => {
+      this.setState({ rootLoading: !0 });
+      const { loadedKeys: r } = this.state;
+      let { treeData: l } = this.state;
+      const h = s ? this.findNode(s, l) : null, n = e ? [...e] : [...r];
+      for (let a = 0; a < n.length; a++) {
+        let d = this.findNode(n[a], l);
+        if (!d && h && n[a - 1]) {
+          const f = this.findNode(n[a - 1], l);
+          f && A(m(f, "children")) && f.children.length > 0 && (d = await this.pageThroughChildrenUntilTaxonFound(
+            f,
+            n[a]
+          ), d ? n.splice(a, 0, d.taxon.id) : this.setState(
+            {
+              nodeNotFoundErr: /* @__PURE__ */ t.jsxs("span", { children: [
+                "Cannot find taxon ",
+                s,
+                " in tree 😥"
+              ] }),
+              rootLoading: !1
+            }
+            /* ,
+            () => {
+              if (
+                this.props.treeType === "CATALOGUE" &&
+                typeof this.props.addMissingTargetKey === "function"
+              ) {
+                this.props.addMissingTargetKey(expandKey);
+              }
+            } */
+          ));
+        }
+        if (d) {
+          await this.fetchChildPage(d, !0, !0);
+          let f = d.children.find(
+            (x) => m(x, "taxon.id") === m(h, "taxon.id")
+          );
+          h && a === n.length - 2 && m(d, "taxon.id") !== m(h, "taxon.id") && A(d.children) && !f && d.children.length < d.childCount && (f = await this.pageThroughChildrenUntilTaxonFound(
+            d,
+            m(h, "taxon.id")
+          ), f ? this.setState({ treeData: [...this.state.treeData] }, () => {
+            setTimeout(() => {
+              document.getElementById(s).scrollIntoView({ behavior: "smooth", block: "center" });
+            }, 100);
+          }) : this.setState(
+            {
+              nodeNotFoundErr: /* @__PURE__ */ t.jsxs("span", { children: [
+                "Cannot find taxon ",
+                s,
+                " in tree 😥"
+              ] }),
+              rootLoading: !1
+            },
+            () => {
+              this.props.treeType === "CATALOGUE" && typeof this.props.addMissingTargetKey == "function" && this.props.addMissingTargetKey(s);
+            }
+          ));
+        }
+      }
+      const u = { loadedKeys: n, rootLoading: !1 };
+      o && (u.expandedKeys = n), this.setState(u, () => {
+        s && setTimeout(() => {
+          document.getElementById(s).scrollIntoView({ behavior: "smooth", block: "center" });
+        }, 100);
+      });
+    });
+    this.state = {
+      rootLoading: !0,
+      treeData: [],
+      loadedKeys: [],
+      expandedKeys: [],
+      rootTotal: 0,
+      error: null,
+      nodeNotFoundErr: null,
+      rank: []
+    }, this.treeRef = j.createRef();
+  }
+  // datasetLoader comes from the shared TreeCacheContext so multiple tree
+  // nodes (and TaxonSources instances) share one in-memory cache instead
+  // of each re-fetching the same source datasets.
+  get datasetLoader() {
+    return this.context.datasetLoader;
+  }
+  render() {
+    const {
+      error: e,
+      rootTotal: s,
+      rootLoading: o,
+      treeData: r,
+      defaultExpandAll: l,
+      nodeNotFoundErr: h,
+      loadedKeys: n,
+      expandedKeys: u
+    } = this.state, { treeType: a, dataset: d, height: f, expandedTaxonKey: x } = this.props, p = x;
+    return /* @__PURE__ */ t.jsxs("div", { children: [
+      e && /* @__PURE__ */ t.jsx(j.Fragment, { children: m(e, "response.data.code") !== 404 ? /* @__PURE__ */ t.jsx(
+        b,
+        {
+          closable: !0,
+          onClose: () => this.setState({ error: null }),
+          style: { marginTop: "8px" },
+          message: /* @__PURE__ */ t.jsx(ue, { error: e }),
+          type: "error"
+        }
+      ) : /* @__PURE__ */ t.jsx(
+        b,
+        {
+          closable: !0,
+          onClose: () => this.setState({ error: null }),
+          style: { marginTop: "8px" },
+          message: /* @__PURE__ */ t.jsx(
+            Custom404,
+            {
+              error: e,
+              treeType: a,
+              dataset: d,
+              loadRoot: this.loadRoot
+            }
+          ),
+          type: "warning"
+        }
+      ) }),
+      h && /* @__PURE__ */ t.jsx(
+        b,
+        {
+          closable: !0,
+          onClose: () => this.setState({ nodeNotFoundErr: null }),
+          style: { marginTop: "8px" },
+          message: h,
+          type: "warning"
+        }
+      ),
+      o && /* @__PURE__ */ t.jsx(oe, { paragraph: { rows: 10 }, active: !0 }),
+      !o && r.length > 0 && /* @__PURE__ */ t.jsx(
+        ie,
+        {
+          ref: this.treeRef,
+          defaultExpandAll: l,
+          loadData: this.onLoadData,
+          onLoad: (i) => this.setState({ loadedKeys: i }),
+          loadedKeys: n,
+          expandedKeys: u,
+          treeData: r,
+          filterTreeNode: (i) => i.key === p,
+          onExpand: (i, g) => {
+            this.setState({ expandedKeys: i }), this.props.onExpandedTaxonKeyChange && this.props.onExpandedTaxonKeyChange(
+              g.expanded ? g.node.key : null
+            );
+          }
+        }
+      ),
+      !e && r.length < s && /* @__PURE__ */ t.jsxs(ne, { loading: o, onClick: this.loadRoot, children: [
+        "Load more",
+        " "
+      ] })
+    ] });
+  }
+}
+c(G, "contextType", w);
+const ye = [
+  "infraspecific name",
+  "species",
+  "variety",
+  "form"
+];
+class Z extends j.Component {
+  constructor(e) {
+    super(e);
+    c(this, "componentDidMount", async () => {
+      const { datasetKey: e, citation: s } = this.props;
+      if (s)
+        try {
+          const { data: o } = await ce(e);
+          this.setState({ dataset: o });
+        } catch {
+        }
+    });
+    c(this, "render", () => {
+      const {
+        datasetKey: e,
+        defaultTaxonKey: s,
+        expandedTaxonKey: o,
+        onExpandedTaxonKeyChange: r,
+        showTreeOptions: l,
+        linkToSpeciesPage: h,
+        citation: n,
+        type: u,
+        insertPlaceholder: a = !0
+      } = this.props, { hideExtinct: d, dataset: f } = this.state, x = (i) => {
+        var P, _;
+        const g = m(i, "key");
+        if (!g) return;
+        const q = m(i, "rank");
+        if (h && ye.includes(q)) {
+          const E = (_ = (P = this.context) == null ? void 0 : P.taxon) == null ? void 0 : _.onNavigate;
+          E && E(g);
+        } else r && (r(g), this.treeRef && this.treeRef.reloadRoot && this.treeRef.reloadRoot());
+      }, p = () => {
+        r && r(null);
+      };
+      return /* @__PURE__ */ t.jsxs("div", { className: "catalogue-of-life", children: [
+        n === "top" && f && /* @__PURE__ */ t.jsx(F, { dataset: f }),
+        /* @__PURE__ */ t.jsx(w.Provider, { value: this.cache, children: /* @__PURE__ */ t.jsxs(z.Provider, { value: this.state, children: [
+          /* @__PURE__ */ t.jsxs(re, { children: [
+            /* @__PURE__ */ t.jsx(v, { flex: "auto", children: /* @__PURE__ */ t.jsx(
+              xe,
+              {
+                hideExtinct: d,
+                datasetKey: e,
+                style: {
+                  width: "100%",
+                  paddingTop: "5px",
+                  paddingBottom: "5px"
+                },
+                defaultTaxonKey: o || null,
+                onSelectName: x,
+                onResetSearch: p
+              }
+            ) }),
+            l && /* @__PURE__ */ t.jsxs(v, { style: { paddingLeft: "8px" }, children: [
+              /* @__PURE__ */ t.jsx(
+                $,
+                {
+                  defaultChecked: this.state.showInfo,
+                  onChange: ({ target: { checked: i } }) => {
+                    this.setState({ showInfo: i }), M("tree-show-source", i);
+                  },
+                  children: "Source"
+                }
+              ),
+              /* @__PURE__ */ t.jsx(
+                $,
+                {
+                  defaultChecked: this.state.hideExtinct,
+                  onChange: ({ target: { checked: i } }) => {
+                    this.setState({ hideExtinct: i }), M("tree-extant-only", i);
+                  },
+                  children: "Extant only"
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ t.jsx(
+            G,
+            {
+              insertPlaceholder: a,
+              hideExtinct: d,
+              datasetKey: e,
+              defaultTaxonKey: s,
+              expandedTaxonKey: o,
+              onExpandedTaxonKeyChange: r,
+              treeRef: (i) => this.treeRef = i,
+              type: u
+            }
+          )
+        ] }) }),
+        n === "bottom" && f && /* @__PURE__ */ t.jsx(F, { dataset: f })
+      ] });
+    });
+    de(this.props.auth), this.state = {
+      hideExtinct: O("tree-extant-only", !1),
+      showInfo: O("tree-show-source", !1),
+      dataset: null
+    }, this.cache = B(this.props.datasetKey);
+  }
+  componentDidUpdate(e) {
+    e.datasetKey !== this.props.datasetKey && (this.cache = B(this.props.datasetKey));
+  }
+}
+c(Z, "contextType", U);
+function me({
+  datasetKey: C,
+  defaultTaxonKey: y,
+  expandedTaxonKey: e,
+  onExpandedTaxonKeyChange: s,
+  showTreeOptions: o,
+  linkToSpeciesPage: r,
+  citation: l,
+  type: h,
+  insertPlaceholder: n,
+  auth: u,
+  ...a
+}) {
+  return /* @__PURE__ */ t.jsx(U.Provider, { value: he(a), children: /* @__PURE__ */ t.jsx(
+    Z,
+    {
+      datasetKey: C,
+      defaultTaxonKey: y,
+      expandedTaxonKey: e,
+      onExpandedTaxonKeyChange: s,
+      showTreeOptions: o,
+      linkToSpeciesPage: r,
+      citation: l,
+      type: h,
+      insertPlaceholder: n,
+      auth: u
+    }
+  ) });
+}
+const Ne = Y(X(me));
+export {
+  Ne as Tree
+};
+//# sourceMappingURL=tree.js.map