@graphty/graphty-element 2.6.2 → 3.0.1

package/dist/chunks/interpolation-Dk206AhZ.js

@@ -0,0 +1,105 @@
+import { z as n } from "zod/v4";
+import { C as d, I as p } from "./common-DWNKjpH_.js";
+const f = ["2d", "3d", "ar", "vr"], b = "3d";
+function k(r) {
+  return f.includes(r);
+}
+const g = n.strictObject({
+  backgroundType: n.literal("color"),
+  color: d
+}), h = n.strictObject({
+  backgroundType: n.literal("skybox"),
+  data: p
+}), m = n.discriminatedUnion("backgroundType", [g, h]), s = n.strictObject({
+  /** The halo's colour. Any colour the element understands; normalised to hex on parse. */
+  color: d.default("#FFD700"),
+  /**
+   * How much of the node's own size the halo is drawn at.
+   *
+   * Greater than 1 puts a ring around the node, which is what a highlight reads as. Below 1 the
+   * halo disappears inside the node it is meant to mark, so the schema takes any positive
+   * number and the default stands a little clear of the node.
+   */
+  scale: n.number().positive().default(1.45),
+  /** How solid the halo is, in `[0, 1]`. Low enough to read as a highlight rather than a node. */
+  opacity: n.number().min(0).max(1).default(0.4)
+}), D = s, I = s.parse({}), y = n.enum(["2d", "3d", "ar", "vr"]), _ = n.strictObject({
+  /**
+   * ACCEPTED AND IGNORED. It used to decide whether the element unshifted a default layer onto
+   * the 1.x layer stack; that stack is gone, and the session's two locked base layers give
+   * every graph its defaults unconditionally. The key stays because this object is strict, so
+   * dropping it would turn every document that still carries it into a parse error.
+   */
+  addDefaultStyle: n.boolean().default(!0),
+  background: m.prefault({ backgroundType: "color", color: "whitesmoke" }),
+  selection: s.optional(),
+  /**
+   * How far the camera starts from the graph, in scene units. Set, it places the camera and
+   * turns off the element's automatic zoom-to-fit; unset, the graph is framed to fit.
+   */
+  startingCameraDistance: n.number().optional(),
+  layout: n.string().optional(),
+  // No default - let Graph constructor set the default
+  layoutOptions: n.looseObject({}).optional(),
+  /**
+   * View mode controls how the graph is rendered and displayed.
+   * - "2d": Orthographic camera, fixed top-down view
+   * - "3d": Perspective camera with orbit controls (default)
+   * - "ar": Augmented reality mode using WebXR
+   * - "vr": Virtual reality mode using WebXR
+   */
+  viewMode: y.default(b),
+  /**
+   * @deprecated Use viewMode instead. twoD: true is equivalent to viewMode: "2d"
+   */
+  twoD: n.boolean().default(!1)
+}), S = "#ff00ff", M = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
+function u(r) {
+  if (typeof r != "string")
+    return null;
+  const t = M.exec(r);
+  return t === null ? null : {
+    r: parseInt(t[1], 16),
+    g: parseInt(t[2], 16),
+    b: parseInt(t[3], 16)
+  };
+}
+function O(r, t, o) {
+  const e = (a) => {
+    const i = Math.round(Math.max(0, Math.min(255, a))).toString(16);
+    return i.length === 1 ? `0${i}` : i;
+  };
+  return `#${e(r)}${e(t)}${e(o)}`;
+}
+function E(r, t, o) {
+  const e = u(r), a = u(t);
+  if (e === null || a === null || !Number.isFinite(o))
+    return null;
+  const i = e.r + (a.r - e.r) * o, c = e.g + (a.g - e.g) * o, l = e.b + (a.b - e.b) * o;
+  return O(i, c, l);
+}
+function w(r, t, o = S) {
+  if (t.length === 0)
+    throw new Error("interpolatePalette was given an empty palette, which has no color to return");
+  if (typeof r != "number" || !Number.isFinite(r))
+    return o;
+  const e = Math.max(0, Math.min(1, r));
+  if (e === 0)
+    return t[0];
+  if (e === 1)
+    return t[t.length - 1];
+  const a = e * (t.length - 1), i = Math.floor(a), c = Math.min(i + 1, t.length - 1), l = a - i;
+  return E(t[i], t[c], l) ?? o;
+}
+export {
+  I as D,
+  m as G,
+  S as M,
+  f as V,
+  b as a,
+  D as b,
+  k as c,
+  _ as d,
+  u as h,
+  w as i
+};

package/dist/chunks/paletteRegistry-De3CGdst.js

@@ -0,0 +1,357 @@
+import { c as N, G as h } from "./pluginRegistry-Ddfl6Mv2.js";
+import { a as O, d as b } from "./types-DFchv4Ny.js";
+import { c as v } from "./common-DWNKjpH_.js";
+const m = N({
+  kind: "format",
+  idOf: (e) => e.descriptor.id,
+  descriptorOf: (e) => e.descriptor,
+  implementationOf: (e) => e.descriptor,
+  builtInIds: () => O
+});
+function P(e, t) {
+  m.register(e, t);
+}
+function S() {
+  return m.entries();
+}
+function E() {
+  return m.descriptors();
+}
+function I(e) {
+  return m.byId(e);
+}
+function M() {
+  m.clearForTesting();
+}
+const j = {
+  "edge-list": "Edge List",
+  "node-list": "Node List",
+  "adjacency-list": "Adjacency List",
+  neo4j: "Neo4j Export",
+  gephi: "Gephi Export",
+  cytoscape: "Cytoscape Export",
+  generic: "Generic"
+}, F = [
+  {
+    name: "delimiter",
+    plainName: "Column Separator",
+    technicalName: "delimiter",
+    type: "string",
+    description: "The character between one column and the next. Worked out from the first line (comma, tab, semicolon or pipe) when it is not set."
+  },
+  {
+    name: "variant",
+    plainName: "File Shape",
+    technicalName: "variant",
+    type: "enum",
+    values: Object.entries(j).map(([e, t]) => ({ value: e, label: t })),
+    description: "Which CSV shape to read. Worked out from the header row when it is not set."
+  },
+  {
+    name: "idColumn",
+    plainName: "Node Id Column",
+    technicalName: "idColumn",
+    type: "string",
+    description: "The column holding each node's identity, when the file lists nodes."
+  }
+], c = [
+  {
+    name: "edgeSource",
+    plainName: "Edge Start Field",
+    technicalName: "edgeSource",
+    type: "string",
+    description: "Where to find the node an edge starts at. Left unset, the element looks for source, then src, then from."
+  },
+  {
+    name: "edgeTarget",
+    plainName: "Edge End Field",
+    technicalName: "edgeTarget",
+    type: "string",
+    description: "Where to find the node an edge ends at. Left unset, the element looks for target, then dst, then to."
+  }
+], w = [
+  {
+    name: "nodeIdPath",
+    plainName: "Node Id Field",
+    technicalName: "nodeIdPath",
+    type: "string",
+    description: "An expression selecting each node's identity out of the node record."
+  }
+], f = [
+  {
+    id: "json",
+    plainName: "JSON",
+    extensions: [".json"],
+    mimeTypes: ["application/json"],
+    canImport: !0,
+    canExport: !1,
+    options: [...w, ...c]
+  },
+  {
+    id: "csv",
+    plainName: "CSV",
+    extensions: [".csv", ".tsv", ".tab", ".edges", ".edgelist"],
+    mimeTypes: ["text/csv", "text/tab-separated-values", "text/plain"],
+    canImport: !0,
+    canExport: !1,
+    options: [...F, ...c]
+  },
+  {
+    id: "graphml",
+    plainName: "GraphML",
+    extensions: [".graphml", ".xml"],
+    mimeTypes: ["application/graphml+xml", "application/xml", "text/xml"],
+    canImport: !0,
+    canExport: !1,
+    options: c
+  },
+  {
+    id: "gexf",
+    plainName: "GEXF",
+    // ".xml" is claimed here as well as by GraphML because both formats are XML and both are
+    // routinely saved under the generic extension. Two claimants is what lets detection ask
+    // each one's content sniffer which of them the file actually is, instead of a private
+    // branch inside the detector hard-coding the two namespace strings -- which is the same
+    // route a third party's XML dialect now takes.
+    extensions: [".gexf", ".xml"],
+    mimeTypes: ["application/gexf+xml", "application/xml", "text/xml"],
+    canImport: !0,
+    canExport: !1,
+    options: c
+  },
+  {
+    id: "gml",
+    plainName: "GML",
+    extensions: [".gml"],
+    mimeTypes: ["text/plain"],
+    canImport: !0,
+    canExport: !1,
+    options: c
+  },
+  {
+    id: "dot",
+    plainName: "DOT",
+    extensions: [".dot", ".gv"],
+    mimeTypes: ["text/vnd.graphviz", "text/plain"],
+    canImport: !0,
+    canExport: !1,
+    options: c
+  },
+  {
+    id: "pajek",
+    plainName: "Pajek NET",
+    extensions: [".net", ".paj"],
+    mimeTypes: ["text/plain"],
+    canImport: !0,
+    canExport: !1,
+    options: c
+  }
+], $ = [
+  {
+    id: "sif",
+    reason: "No data source reads the Cytoscape simple interaction format. The name is deprecated and is removed at the next major release unless a reader lands."
+  },
+  {
+    id: "cx2",
+    reason: "No data source reads the Cytoscape Exchange format. The name is deprecated and is removed at the next major release unless a reader lands."
+  }
+];
+function z(e) {
+  return f.find((t) => t.id === e) ?? I(e)?.descriptor;
+}
+function G(e) {
+  const t = e.toLowerCase();
+  return [...f, ...E()].filter(
+    (n) => n.extensions.includes(t)
+  );
+}
+function p(e) {
+  return e.startsWith("<");
+}
+const y = [
+  // The root element names the format, whatever namespace it declares: GEXF 1.2 declares
+  // "http://www.gexf.net/1.2draft" and 1.3 "http://gexf.net/1.3".
+  { id: "graphml", detect: (e) => p(e) && /<graphml[\s>]/.test(e) },
+  { id: "gexf", detect: (e) => p(e) && /<gexf[\s>]/.test(e) },
+  { id: "json", detect: (e) => e.startsWith("{") || e.startsWith("[") },
+  { id: "gml", detect: (e) => !p(e) && /graph\s*\[/i.test(e) },
+  { id: "pajek", detect: (e) => /^\*vertices/i.test(e) },
+  { id: "dot", detect: (e) => /^\s*(strict\s+)?(di)?graph\s+/i.test(e) },
+  { id: "csv", detect: (e) => !p(e) && /^[\w-]+[ \t]*[,\t;|][ \t]*[\w-]+/m.test(e) }
+];
+function g(e, t) {
+  try {
+    return e(t);
+  } catch {
+    return !1;
+  }
+}
+function k(e) {
+  return /\.[^.]+$/.exec(e.toLowerCase())?.[0] ?? null;
+}
+function A(e) {
+  const t = e.sample?.trim() ?? "", n = S(), r = e.filename === void 0 ? null : k(e.filename);
+  if (r !== null) {
+    const i = [
+      ...f.filter((a) => a.extensions.includes(r)).map(
+        (a) => a.id
+      ),
+      ...n.filter((a) => a.descriptor.extensions.includes(r)).map((a) => a.descriptor.id)
+    ];
+    if (i.length > 1 && t !== "") {
+      const a = new Map([
+        ...y.map((o) => [o.id, o.detect]),
+        ...n.filter((o) => o.detect !== void 0).map((o) => [o.descriptor.id, o.detect])
+      ]), d = i.filter((o) => {
+        const x = a.get(o);
+        return x !== void 0 && g(x, t);
+      });
+      if (d.length > 0)
+        return Object.freeze([...d, ...i.filter((o) => !d.includes(o))]);
+    }
+    if (i.length > 0)
+      return Object.freeze(i);
+  }
+  if (t === "")
+    return Object.freeze([]);
+  const s = y.filter((i) => g(i.detect, t)).map(
+    (i) => i.id
+  );
+  for (const i of n) {
+    const { detect: a } = i;
+    a !== void 0 && g(a, t) && !s.includes(i.descriptor.id) && s.push(i.descriptor.id);
+  }
+  return Object.freeze(s);
+}
+function U(e) {
+  return A(e)[0] ?? null;
+}
+function T() {
+  return [
+    ...f.map((e) => e.id),
+    ...S().map((e) => e.descriptor.id)
+  ];
+}
+function B(e) {
+  const t = T(), n = $.find((s) => s.id === e), r = n === void 0 ? `no format is named "${e}".` : `the format "${e}" cannot be read: ${n.reason}`;
+  return new h({
+    code: "E_UNKNOWN_FORMAT",
+    message: `${r} The formats this element can read are: ${t.join(", ")}. A format of your own is registered with \`DataSource.register\`.`,
+    source: "data",
+    details: { format: e, available: [...t] }
+  });
+}
+function K(e, t) {
+  const n = T();
+  return new h({
+    code: "E_UNKNOWN_FORMAT",
+    message: `nothing recognised the format of "${e}". The formats this element can read are: ${n.join(", ")}. Name one explicitly: ${t}`,
+    source: "data",
+    details: { source: e, available: [...n] }
+  });
+}
+const _ = /^#[0-9a-f]{6}$/i;
+function C(e) {
+  if (typeof e != "string" || e.trim() === "")
+    return null;
+  try {
+    const t = v(e.trim());
+    if (t === void 0)
+      return null;
+    const n = t.length === 9 ? t.slice(0, 7) : t;
+    return _.test(n) ? n.toUpperCase() : null;
+  } catch {
+    return null;
+  }
+}
+function D(e) {
+  return JSON.stringify([
+    e.id,
+    e.kind,
+    e.colors,
+    e.capacity,
+    e.colorblindSafe
+  ]);
+}
+const u = N({
+  kind: "palette",
+  idOf: (e) => e.id,
+  descriptorOf: (e) => e,
+  implementationOf: D,
+  builtInIds: () => b
+});
+function l(e, t, n) {
+  throw new h({
+    code: "E_BAD_COMMAND",
+    message: n,
+    source: "registry",
+    details: { kind: "palette", name: typeof e == "string" ? e : "", field: t }
+  });
+}
+function V(e, t) {
+  typeof e != "object" && l("", "descriptor", "registerPalette takes a palette descriptor"), (e.plainName === void 0 || e.plainName === "") && l(
+    e.id,
+    "plainName",
+    `the palette "${String(e.id)}" was registered without a plain name`
+  ), e.kind !== "sequential" && e.kind !== "diverging" && e.kind !== "categorical" && l(
+    e.id,
+    "kind",
+    `the palette "${String(e.id)}" must be sequential, diverging or categorical`
+  ), (!Array.isArray(e.colors) || e.colors.length === 0) && l(e.id, "colors", `the palette "${String(e.id)}" was registered with no colours`);
+  const n = [];
+  for (const a of e.colors) {
+    const d = C(a);
+    d === null && l(
+      e.id,
+      "colors",
+      `"${String(a)}" in the palette "${String(e.id)}" is not a colour`
+    ), n.push(d);
+  }
+  const r = e.colorblindSafe ?? [], s = ["deuteranopia", "protanopia", "tritanopia"];
+  (!Array.isArray(r) || r.some((a) => !s.includes(a))) && l(
+    e.id,
+    "colorblindSafe",
+    `the palette "${String(e.id)}" claims colorblindSafe ${JSON.stringify(r)}; a claim lists "deuteranopia", "protanopia" or "tritanopia"`
+  );
+  const i = e.kind === "categorical" ? n.length : null;
+  e.capacity !== void 0 && e.capacity !== i && l(
+    e.id,
+    "capacity",
+    `the palette "${String(e.id)}" is ${e.kind}, so its capacity is ${i === null ? "null" : String(i)} rather than ${String(e.capacity)}`
+  ), u.register(
+    Object.freeze({
+      ...e,
+      colors: Object.freeze(n),
+      capacity: i,
+      colorblindSafe: Object.freeze(e.colorblindSafe ?? [])
+    }),
+    t
+  );
+}
+function X() {
+  return u.descriptors();
+}
+function H(e) {
+  return u.byId(e);
+}
+function J() {
+  u.clearForTesting();
+}
+export {
+  f as F,
+  $ as U,
+  J as a,
+  A as b,
+  M as c,
+  U as d,
+  E as e,
+  X as f,
+  z as g,
+  G as h,
+  H as i,
+  B as j,
+  C as n,
+  P as p,
+  V as r,
+  K as u
+};