@graphty/graphty-element 2.6.2 → 3.0.1

package/dist/chunks/parse-SVp77JbE.js

@@ -0,0 +1,669 @@
+import { V as z, Y as W, g as J, I as Q, B as X, G as Z, d as v, O as N, i as R, T as I, P as C, C as L, h as ee, b as ie, R as te, a as _, c as D, e as T } from "./sequential-Zym81qm7.js";
+import { i as ne, f as K } from "./paletteRegistry-De3CGdst.js";
+import { G as oe } from "./pluginRegistry-Ddfl6Mv2.js";
+import { I as w, J as q, K as y, M as re } from "./fields-5uVC1Pll.js";
+const a = ["deuteranopia", "protanopia", "tritanopia"], S = Object.freeze([
+  {
+    id: "viridis",
+    plainName: "Purple to Yellow",
+    kind: "sequential",
+    colors: z,
+    capacity: null,
+    colorblindSafe: a
+  },
+  // Paul Tol, "Colour Schemes" (2021): YlOrBr, trimmed to the steps that stand off a light
+  // background. The default for a measurement.
+  {
+    id: "ylorbr",
+    plainName: "Orange to Brown",
+    kind: "sequential",
+    colors: W,
+    capacity: null,
+    colorblindSafe: a
+  },
+  {
+    id: "plasma",
+    plainName: "Blue to Yellow",
+    kind: "sequential",
+    colors: J,
+    capacity: null,
+    colorblindSafe: a
+  },
+  {
+    id: "inferno",
+    plainName: "Black to Yellow",
+    kind: "sequential",
+    colors: Q,
+    capacity: null,
+    colorblindSafe: a
+  },
+  {
+    id: "blues",
+    plainName: "Shades of Blue",
+    kind: "sequential",
+    colors: X,
+    capacity: null,
+    colorblindSafe: a
+  },
+  {
+    id: "greens",
+    plainName: "Shades of Green",
+    kind: "sequential",
+    colors: Z,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "oranges",
+    plainName: "Shades of Orange",
+    kind: "sequential",
+    colors: v,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "okabe-ito",
+    plainName: "Eight Distinct Colours",
+    kind: "categorical",
+    colors: N,
+    capacity: N.length,
+    colorblindSafe: a
+  },
+  {
+    id: "tol-vibrant",
+    plainName: "Seven Bright Colours",
+    kind: "categorical",
+    colors: R,
+    capacity: R.length,
+    colorblindSafe: a
+  },
+  {
+    id: "tol-muted",
+    plainName: "Nine Soft Colours",
+    kind: "categorical",
+    colors: I,
+    capacity: I.length,
+    colorblindSafe: a
+  },
+  {
+    id: "pastel",
+    plainName: "Eight Pale Colours",
+    kind: "categorical",
+    colors: C,
+    capacity: C.length,
+    colorblindSafe: a
+  },
+  {
+    id: "carbon",
+    plainName: "Five Enterprise Colours",
+    kind: "categorical",
+    colors: L,
+    capacity: L.length,
+    colorblindSafe: []
+  },
+  {
+    id: "purple-green",
+    plainName: "Purple to Green",
+    kind: "diverging",
+    colors: ee,
+    capacity: null,
+    colorblindSafe: a
+  },
+  {
+    id: "blue-orange",
+    plainName: "Blue to Orange",
+    kind: "diverging",
+    colors: ie,
+    capacity: null,
+    colorblindSafe: a
+  },
+  {
+    id: "red-blue",
+    plainName: "Red to Blue",
+    kind: "diverging",
+    colors: te,
+    capacity: null,
+    colorblindSafe: []
+  },
+  {
+    id: "blue-highlight",
+    plainName: "Blue Highlight",
+    kind: "categorical",
+    colors: [_.highlighted, _.muted],
+    capacity: 2,
+    colorblindSafe: a
+  },
+  {
+    id: "green-highlight",
+    plainName: "Green Highlight",
+    kind: "categorical",
+    colors: [D.highlighted, D.muted],
+    capacity: 2,
+    colorblindSafe: a
+  },
+  {
+    id: "orange-highlight",
+    plainName: "Orange Highlight",
+    kind: "categorical",
+    colors: [T.highlighted, T.muted],
+    capacity: 2,
+    colorblindSafe: a
+  }
+]);
+function Se(e) {
+  return S.find((i) => i.id === e) ?? ne(e);
+}
+function ke(e) {
+  const i = S.filter((t) => t.kind === e), n = K().filter((t) => t.kind === e);
+  return n.length === 0 ? i : [...i, ...n];
+}
+function Oe() {
+  return [...S, ...K()].map((e) => String(e.id));
+}
+const f = {
+  name: "reverse",
+  plainName: "Reverse",
+  technicalName: "reverse",
+  type: "boolean",
+  default: !1,
+  description: "Send the smallest value to the far end of the range instead of the near end."
+}, l = {
+  name: "midpoint",
+  plainName: "Midpoint",
+  technicalName: "midpoint",
+  type: "number",
+  description: "The value that lands on the middle colour of a diverging palette."
+};
+function x(e, i, n) {
+  return {
+    name: "bins",
+    plainName: e,
+    technicalName: "bins",
+    type: "integer",
+    default: n,
+    min: 2,
+    max: 20,
+    step: 1,
+    description: i
+  };
+}
+const M = [
+  {
+    name: "linear",
+    plainName: "Even Steps",
+    domainKind: "numeric",
+    options: [f, l]
+  },
+  {
+    name: "log",
+    plainName: "By Order of Magnitude",
+    domainKind: "numeric",
+    options: [f, l]
+  },
+  {
+    name: "neglog10",
+    plainName: "By Significance",
+    domainKind: "numeric",
+    options: [f, l]
+  },
+  {
+    name: "sqrt",
+    plainName: "By Area",
+    domainKind: "numeric",
+    options: [f, l]
+  },
+  {
+    name: "pow",
+    plainName: "Curved",
+    domainKind: "numeric",
+    options: [
+      {
+        name: "exponent",
+        plainName: "Exponent",
+        technicalName: "exponent",
+        type: "number",
+        default: 1,
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        description: "How hard the curve bends. Below one spreads the small values out; above one spreads the large ones out."
+      },
+      f,
+      l
+    ]
+  },
+  {
+    name: "bins",
+    plainName: "Equal Ranges",
+    domainKind: "numeric",
+    options: [
+      x("Groups", "How many equally wide ranges to cut the values into.", 5),
+      f
+    ]
+  },
+  {
+    name: "quantile",
+    plainName: "Equal Counts",
+    domainKind: "numeric",
+    options: [
+      x("Groups", "How many groups of equal size to sort the values into.", 4),
+      f
+    ]
+  },
+  {
+    name: "ordinal",
+    plainName: "One Colour per Value",
+    domainKind: "categorical",
+    options: [f]
+  },
+  {
+    name: "passthrough",
+    plainName: "Use the Value As It Is",
+    domainKind: "categorical",
+    options: []
+  }
+];
+function Ee(e) {
+  return M.find((i) => i.name === e);
+}
+function Ne(e) {
+  return M.filter((i) => i.domainKind === e);
+}
+const se = /* @__PURE__ */ new Set([
+  "fixed.weights",
+  "rule.scope",
+  "edgeMember.key",
+  "edgeMember.dataSource",
+  "set.graph",
+  "search",
+  "threshold.percentile",
+  "threshold.z",
+  "threshold.population",
+  "itemKey.op",
+  "itemKey.smallestNode",
+  "itemKey.edges",
+  "itemKey.binds"
+]), de = ["visible", "graph", "selection", "largest-component"], ae = ["induced", "listed", "clipped"], ce = ["in", "out", "all"];
+function o(e, i = {}) {
+  return new oe({ code: "E_BAD_COMMAND", message: e, source: "data", details: i });
+}
+function c(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function b(e) {
+  return typeof e == "number" && Number.isFinite(e);
+}
+function h(e) {
+  return typeof e == "string" || b(e);
+}
+class k {
+  constructor(i) {
+    this.mode = i;
+  }
+  /**
+   * Meet a kind or field this element does not define: refused at a door, remembered on load.
+   * @param name - The kind, or `<node>.<field>`.
+   * @param what - How to say it in a refusal.
+   */
+  unknown(i, n) {
+    if (this.mode === "door") {
+      const t = se.has(i);
+      throw o(
+        t ? `"${i}" is reserved for a later release of graphty-element and cannot be used yet.` : `${n} "${i}" is not one graphty-element knows.`,
+        t ? { field: i, reserved: !0 } : { name: i }
+      );
+    }
+    this.first ??= i;
+  }
+  /**
+   * Meet every field of a node outside its known list, in code-unit order.
+   * @param value - The node.
+   * @param node - Its name, for `<node>.<field>`.
+   * @param known - The fields it defines.
+   */
+  fields(i, n, t) {
+    for (const r of Object.keys(i).sort())
+      i[r] !== void 0 && !t.includes(r) && this.unknown(`${n}.${r}`, "The field");
+  }
+}
+function p(e, i) {
+  if (!Array.isArray(e))
+    throw o(`${i} is a list of node ids.`, { value: e });
+  for (const n of e)
+    if (!h(n))
+      throw o(`${i} holds ${String(n)}, which is not a node id: an id is a string or a finite number.`, {
+        id: n
+      });
+}
+function B(e, i) {
+  if (!c(e))
+    throw o(
+      "An edge member is an object with a source, a target and one of id, key or ordinal with among. A session edge id is accepted only at a write door, which stores its stable form.",
+      { member: e }
+    );
+  if (i.fields(e, "edgeMember", re), !h(e.source) || !h(e.target))
+    throw o("An edge member's source and target are node ids.", { member: e });
+  const n = e.ordinal !== void 0;
+  if (n !== (e.among !== void 0))
+    throw o("An edge member's ordinal and among come together or not at all.", { member: e });
+  if ([e.id, e.key, e.ordinal].filter((r) => r !== void 0).length !== 1)
+    throw o("An edge member names its edge by exactly one of id, key or ordinal with among.", { member: e });
+  if (e.id !== void 0 && !h(e.id))
+    throw o("An edge member's id is a string or a finite number.", { member: e });
+  if (e.key !== void 0) {
+    if (!h(e.key))
+      throw o("An edge member's key is a string or a finite number.", { member: e });
+    i.unknown("edgeMember.key", "The field");
+  }
+  if (n) {
+    const { ordinal: r, among: d } = e;
+    if (!Number.isInteger(d) || d < 1 || !Number.isInteger(r) || r < 0 || r >= d)
+      throw o("An edge member's ordinal counts from 0 and is below among, a whole number from 1.", {
+        member: e
+      });
+  }
+}
+function m(e, i) {
+  if (typeof e != "string" || e.trim() === "")
+    throw o(`${i} needs a query. An empty one matches every element rather than none.`, { where: e });
+}
+function $(e) {
+  for (const i of ["min", "max"])
+    if (e[i] !== void 0 && !b(e[i]))
+      throw o(`A "${String(e.kind)}" leaf's ${i} must be a finite number.`, { [i]: e[i] });
+  if (e.min !== void 0 && e.max !== void 0 && e.min > e.max)
+    throw o(`A "${String(e.kind)}" leaf's min is above its max.`, { min: e.min, max: e.max });
+}
+function fe(e, i) {
+  if (!c(e))
+    throw o("An item leaf's item is an object with a result and a key.", { item: e });
+  i.fields(e, "resultItem", ["result", "run", "key"]);
+  const n = i.mode === "door" ? q(e.result) : e.result;
+  if (typeof n != "string" || n === "")
+    throw o("An item names its result by the result's id.", { result: e.result });
+  if (e.run !== void 0 && (typeof e.run != "string" || e.run === ""))
+    throw o("An item's run is the token of the run it holds.", { run: e.run });
+  const { key: t } = e;
+  if (!c(t))
+    throw o(`An item's key is an object, such as { field: "group", value: 3 }.`, { key: t });
+  if (t.field === void 0) {
+    i.unknown(`itemKey.${Object.keys(t).sort()[0] ?? "{}"}`, "The item key form");
+    return;
+  }
+  if (i.fields(t, "itemKey", ["field", "value"]), typeof t.field != "string" || t.field === "")
+    throw o("An item key's field names a field of the result.", { key: t });
+  const { value: r } = t;
+  if (typeof r != "string" && typeof r != "boolean" && !b(r))
+    throw o("An item key's value is a string, a finite number or a boolean.", { key: t });
+}
+function le(e) {
+  if (typeof e != "string")
+    return !1;
+  if (e.startsWith("data."))
+    return e.length > 5;
+  const i = e.startsWith("results.") ? e.slice(8) : "", n = i.indexOf(".");
+  return n > 0 && n < i.length - 1;
+}
+function he(e, i) {
+  if (i.fields(e, "threshold", ["kind", "path", "top", "above"]), j(e.path), !le(e.path))
+    throw o(`A "threshold" leaf's path is "data.<field>" or "results.<run>.<field>".`, { path: e.path });
+  const n = i.mode === "load" && (e.percentile !== void 0 || e.z !== void 0), t = [e.top, e.above].filter((r) => r !== void 0).length;
+  if (t !== 1 && !(n && t === 0))
+    throw o('A "threshold" leaf has exactly one cut: top or above.', { top: e.top, above: e.above });
+  if (e.top !== void 0 && (!Number.isInteger(e.top) || e.top < 0))
+    throw o(`A "threshold" leaf's top is a whole number of elements.`, { top: e.top });
+  if (e.above !== void 0 && !b(e.above))
+    throw o(`A "threshold" leaf's above is a finite number.`, { above: e.above });
+}
+const me = ["data", "results"];
+function j(e) {
+  if (typeof e != "string" || e === "")
+    return;
+  const i = e.split(".")[0];
+  if (!me.includes(i))
+    throw o(
+      `A field path starts with "data." or "results.", so "${e}" is refused: the root "${i}" is reserved.`,
+      {
+        path: e,
+        root: i,
+        reason: "reserved-root"
+      }
+    );
+}
+function G(e, i) {
+  i.mode === "door" && j(e);
+}
+function u(e, i) {
+  if (!c(e) || typeof e.kind != "string")
+    throw o("A rule tree node is an object with a kind.", { node: e });
+  const { kind: n } = e, t = (r) => {
+    i.fields(e, n, ["kind", ...r]);
+  };
+  switch (n) {
+    case "expression":
+    case "edges":
+      t(["where"]), m(e.where, `An "${n}" leaf`);
+      return;
+    case "range":
+      t(["attribute", "min", "max"]), m(e.attribute, `A "range" leaf's attribute`), G(e.attribute, i), $(e);
+      return;
+    case "categories":
+      if (t(["attribute", "values"]), m(e.attribute, `A "categories" leaf's attribute`), G(e.attribute, i), !Array.isArray(e.values) || !e.values.every((r) => typeof r == "string"))
+        throw o(`A "categories" leaf's values are a list of strings.`, { values: e.values });
+      return;
+    case "degree":
+      if (t(["min", "max", "direction"]), $(e), e.direction !== void 0 && !ce.includes(e.direction))
+        throw o(`A "degree" leaf's direction is "in", "out" or "all".`, { direction: e.direction });
+      return;
+    case "component":
+      if (t(["id"]), !Number.isInteger(e.id) || e.id < 0)
+        throw o(`A "component" leaf's id is a component number, counting from 0.`, { id: e.id });
+      return;
+    case "neighborhood":
+      if (t(["seeds", "depth"]), p(e.seeds, `A "neighborhood" leaf's seeds`), !Number.isInteger(e.depth) || e.depth < 0)
+        throw o(`A "neighborhood" leaf's depth is a whole number of hops, from 0.`, { depth: e.depth });
+      return;
+    case "member":
+      t(["of"]), F(e.of, i);
+      return;
+    case "item":
+      t(["item"]), fe(e.item, i);
+      return;
+    case "threshold":
+      he(e, i);
+      return;
+    case "all":
+    case "any":
+      if (t(["of"]), !Array.isArray(e.of))
+        throw o(`An "${n}" node's operands are a list.`, { of: e.of });
+      for (const r of e.of)
+        u(r, i);
+      return;
+    case "not":
+      t(["of"]), u(e.of, i);
+      return;
+    default:
+      i.unknown(n, "The rule leaf kind");
+  }
+}
+function ge(e, i) {
+  return e === "visible" ? "clipped" : c(e) ? c(e.define) ? e.define.kind === "path" ? "listed" : typeof e.define.reading == "string" ? e.define.reading : "induced" : typeof e.set == "string" ? i?.(e.set) ?? "induced" : "induced" : "induced";
+}
+function A(e, i, n) {
+  if (!c(e))
+    return !1;
+  switch (e.kind) {
+    case "edges":
+      return !0;
+    case "member":
+      return ge(e.of, i) !== "induced";
+    case "item": {
+      const t = c(e.item) ? e.item : {}, r = c(t.key) ? t.key : {}, d = q(t.result);
+      return typeof d == "string" && typeof r.field == "string" && n?.(`results.${d}.${r.field}`).includes("edge") === !0;
+    }
+    case "threshold":
+      return typeof e.path == "string" && n?.(e.path).includes("edge") === !0;
+    case "all":
+    case "any":
+      return Array.isArray(e.of) && e.of.some((t) => A(t, i, n));
+    case "not":
+      return A(e.of, i, n);
+    default:
+      return !1;
+  }
+}
+function pe() {
+  return o(
+    `An induced set derives its edges from its nodes, so this rule's edge-speaking leaf would be ignored. Read it "clipped" or "listed" instead.`,
+    { reason: "induced-edge-leaf" }
+  );
+}
+function F(e, i) {
+  if (typeof e == "string") {
+    de.includes(e) || i.unknown(e, "The scope keyword");
+    return;
+  }
+  if (!c(e))
+    throw o(
+      'A scope is "visible", "graph", "selection", "largest-component", { set }, { where }, { nodes } or { define }.',
+      {
+        scope: e
+      }
+    );
+  if (e.set !== void 0) {
+    if (i.fields(e, "set", ["set"]), typeof e.set != "string" || e.set === "")
+      throw o("A { set } scope names a set by its id.", { scope: e });
+  } else e.where !== void 0 ? (i.fields(e, "where", ["where"]), m(e.where, "A { where } scope")) : e.nodes !== void 0 ? (i.fields(e, "nodes", ["nodes"]), p(e.nodes, "A { nodes } scope")) : e.define !== void 0 ? (i.fields(e, "define", ["define"]), U(e.define, i)) : i.unknown(Object.keys(e).sort()[0] ?? "{}", "The scope form");
+}
+function P(e) {
+  if (!ae.includes(e))
+    throw o(`A set's reading is "induced", "listed" or "clipped".`, { reading: e });
+}
+function H(e, i) {
+  const n = new k(i);
+  return U(e, n), n;
+}
+function U(e, i) {
+  if (!c(e) || typeof e.kind != "string")
+    throw o('A set definition is an object whose kind is "fixed", "rule" or "path".', { definition: e });
+  switch (e.kind) {
+    case "fixed":
+      if (i.fields(e, "fixed", y.fixed), p(e.nodes, "A fixed set's nodes"), P(e.reading), e.edges !== void 0) {
+        if (!Array.isArray(e.edges))
+          throw o("A fixed set's edges are a list of edge members.", { edges: e.edges });
+        for (const n of e.edges)
+          B(n, i);
+      }
+      break;
+    case "rule":
+      if (i.fields(e, "rule", y.rule), P(e.reading), typeof e.where == "string" ? m(e.where, "A rule") : u(e.where, i), i.mode === "door" && e.reading === "induced" && A(e.where))
+        throw pe();
+      break;
+    case "path": {
+      i.fields(e, "path", y.path), p(e.nodes, "A path's nodes");
+      const n = e.nodes;
+      if (n.length === 0)
+        throw o("A path has at least one node; one node is a path of length zero.");
+      if (e.directed !== void 0 && typeof e.directed != "boolean")
+        throw o("A path's directed is true or false.", { directed: e.directed });
+      if (e.edges !== void 0) {
+        if (!Array.isArray(e.edges) || e.edges.length !== n.length - 1)
+          throw o(`A path of ${n.length} nodes names ${n.length - 1} steps' edges, one per step.`, {
+            edges: e.edges
+          });
+        e.edges.forEach((t, r) => {
+          if (t !== null) {
+            if (Array.isArray(t) && t.length === 0)
+              throw o(
+                "A path step's edge group names at least one edge; null means every edge of the pair."
+              );
+            for (const d of Array.isArray(t) ? t : [t])
+              B(d, i), ue(d, n[r], n[r + 1], r, i);
+          }
+        });
+      }
+      break;
+    }
+    default:
+      i.unknown(e.kind, "The set definition kind");
+  }
+}
+function ue(e, i, n, t, r) {
+  const d = e.source === i && e.target === n || e.source === n && e.target === i;
+  if (r.mode === "door" && !d)
+    throw o(
+      `A path's step ${t} names an edge from "${String(e.source)}" to "${String(e.target)}", which does not join its nodes.`,
+      {
+        step: t,
+        edge: e,
+        nodes: [i, n]
+      }
+    );
+}
+function Re(e) {
+  return H(e, "door"), w(e);
+}
+function Ie(e) {
+  const { first: i } = H(e, "load"), n = w(e);
+  return i === void 0 ? { definition: n } : { definition: n, opaque: { first: i } };
+}
+function Ce(e) {
+  u(e, new k("door"));
+}
+function Le(e) {
+  return F(e, new k("door")), c(e) && e.define !== void 0 ? Object.freeze({ define: w(e.define) }) : e;
+}
+function _e(e, i) {
+  const n = (t) => {
+    if (!c(t))
+      return t;
+    const r = (s, g) => g === t[s] ? t : { ...t, [s]: g }, d = (s, g) => {
+      if (!Array.isArray(s))
+        return s;
+      const E = s.map(g);
+      return E.every((V, Y) => V === s[Y]) ? s : E;
+    }, O = (s) => typeof s == "string" || c(s) ? i(s) : s;
+    if (t.define !== void 0)
+      return r("define", n(t.define));
+    if (t.match === "member")
+      return r("of", n(t.of));
+    switch (t.kind) {
+      case "fixed":
+      case "path":
+        return r(
+          "edges",
+          d(t.edges, (s) => Array.isArray(s) ? d(s, O) : O(s))
+        );
+      case "rule":
+        return r("where", n(t.where));
+      case "member":
+        return r("of", n(t.of));
+      case "all":
+      case "any":
+        return r("of", d(t.of, n));
+      case "not":
+        return r("of", n(t.of));
+      default:
+        return t;
+    }
+  };
+  return n(e);
+}
+export {
+  ae as E,
+  S as P,
+  M as S,
+  Re as a,
+  Se as b,
+  ke as c,
+  Ne as d,
+  A as e,
+  _e as f,
+  Ce as g,
+  pe as i,
+  Oe as k,
+  Ie as l,
+  Le as p,
+  ge as r,
+  Ee as s
+};