@graphty/graphty-element 2.3.1 → 2.4.1

package/dist/chunks/{paletteRegistry-x7WOEKZY.js → paletteRegistry-jg9uS7wo.js}

@@ -1,9 +1,9 @@
-import { q as b, G as F } from "./GraphtyLogger-5KEttFUo.js";
-import { a as T, b as D, d as k } from "./types-B7bX5c0K.js";
+import { c as b, G as g, S as F } from "./pluginRegistry-MaTIDh6l.js";
+import { a as T, b as D, d as k } from "./types-C_c53VgR.js";
 import { remapArray as S, INVALID_INDEX as N } from "@graphty/graph-format";
 import { z as O } from "zod/v4";
-import { G as g } from "./GraphtyError-BwcnblTH.js";
-import { c as v } from "./common-DWNKjpH_.js";
+import { G as v } from "./GraphtyLogger-kbOx2zq3.js";
+import { c as L } from "./common-DWNKjpH_.js";
 const f = b({
   kind: "format",
   idOf: (i) => i.descriptor.id,
@@ -11,22 +11,22 @@ const f = b({
   implementationOf: (i) => i.descriptor,
   builtInIds: () => T
 });
-function it(i, t) {
+function st(i, t) {
   f.register(i, t);
 }
-function st() {
+function rt() {
   return f.entries();
 }
-function L() {
+function $() {
   return f.descriptors();
 }
-function $(i) {
+function M(i) {
   return f.byId(i);
 }
-function rt() {
+function nt() {
   f.clearForTesting();
 }
-const M = {
+const R = {
   "edge-list": "Edge List",
   "node-list": "Node List",
   "adjacency-list": "Adjacency List",
@@ -34,7 +34,7 @@ const M = {
   gephi: "Gephi Export",
   cytoscape: "Cytoscape Export",
   generic: "Generic"
-}, R = [
+}, j = [
   {
     name: "delimiter",
     plainName: "Column Separator",
@@ -47,7 +47,7 @@ const M = {
     plainName: "File Shape",
     technicalName: "variant",
     type: "enum",
-    values: Object.entries(M).map(([i, t]) => ({ value: i, label: t })),
+    values: Object.entries(R).map(([i, t]) => ({ value: i, label: t })),
     description: "Which CSV shape to read. Worked out from the header row when it is not set."
   },
   {
@@ -72,7 +72,7 @@ const M = {
     type: "string",
     description: "Where to find the node an edge ends at. Left unset, the element looks for target, then dst, then to."
   }
-], j = [
+], z = [
   {
     name: "nodeIdPath",
     plainName: "Node Id Field",
@@ -88,7 +88,7 @@ const M = {
     mimeTypes: ["application/json"],
     canImport: !0,
     canExport: !1,
-    options: [...j, ...h]
+    options: [...z, ...h]
   },
   {
     id: "csv",
@@ -97,7 +97,7 @@ const M = {
     mimeTypes: ["text/csv", "text/tab-separated-values", "text/plain"],
     canImport: !0,
     canExport: !1,
-    options: [...R, ...h]
+    options: [...j, ...h]
   },
   {
     id: "graphml",
@@ -149,16 +149,16 @@ const M = {
     canExport: !1,
     options: h
   }
-], nt = [
+], ot = [
   { id: "sif", reason: "No data source reads the Cytoscape simple interaction format." },
   { id: "cx2", reason: "No data source reads the Cytoscape Exchange format." }
 ];
-function ot(i) {
-  return _.find((t) => t.id === i) ?? $(i)?.descriptor;
-}
 function at(i) {
+  return _.find((t) => t.id === i) ?? M(i)?.descriptor;
+}
+function lt(i) {
   const t = i.toLowerCase();
-  return [..._, ...L()].filter(
+  return [..._, ...$()].filter(
     (e) => e.extensions.includes(t)
   );
 }
@@ -169,19 +169,19 @@ const m = b({
   implementationOf: (i) => i.descriptor,
   builtInIds: () => D
 });
-function z(i, t) {
+function B(i, t) {
   m.register(i, t);
 }
-function lt() {
+function ct() {
   return m.descriptors();
 }
-function ct(i) {
+function ht(i) {
   return m.byId(i);
 }
-function ht() {
+function dt() {
   m.clearForTesting();
 }
-const o = 3, B = 1024;
+const o = 3, C = 1024;
 function p(i, t) {
   if (!Number.isInteger(i) || i < 0)
     throw new RangeError(`ElementPositions: ${t} must be a non-negative integer, found ${String(i)}`);
@@ -195,7 +195,7 @@ class x {
    * Allocate the backing array, every row unplaced and unpinned.
    * @param capacity - rows to reserve before the first growth; a non-negative integer
    */
-  constructor(t = B) {
+  constructor(t = C) {
     this.components = o, this.rows = 0, p(t, "capacity");
     const e = Math.max(1, t);
     this.array = new Float32Array(o * e), this.array.fill(Number.NaN), this.pins = new Uint8Array(e);
@@ -445,7 +445,7 @@ class x {
     return o * t;
   }
 }
-const l = /* @__PURE__ */ new Map(), C = Object.freeze([
+const l = new F("layout"), W = Object.freeze([
   "arf",
   "bfs",
   "bipartite",
@@ -453,21 +453,23 @@ const l = /* @__PURE__ */ new Map(), C = Object.freeze([
   "d3",
   "fixed",
   "forceatlas2",
+  "grid",
   "kamada-kawai",
   "multipartite",
   "ngraph",
   "planar",
+  "radial",
   "random",
   "shell",
   "spectral",
   "spiral",
   "spring",
   "spring-electrical"
-]), W = F.getLogger(["graphty", "layout"]), P = 1e-6;
-function G(i, t) {
+]), G = v.getLogger(["graphty", "layout"]), P = 1e-6;
+function U(i, t) {
   return JSON.stringify([i, t]);
 }
-const U = 10;
+const V = 10;
 function A(i) {
   return new g({
     code: "E_DUPLICATE_PLUGIN",
@@ -500,7 +502,7 @@ const E = class E {
    * Take a node out of the layout, before the element disposes the mesh that drew it.
    *
    * Declared here, with a default that does nothing, because it used to be duck-typed by the
-   * element's data manager and implemented by none of the seventeen engines that ship here: an
+   * element's data manager and implemented by none of the nineteen engines that ship here: an
    * author learned it existed by reading the element's source, and got no worked example. An
    * engine that keeps its own node list must override this, or it holds every removed node --
    * and everything that node references -- for as long as the engine lives.
@@ -526,7 +528,7 @@ const E = class E {
    * @param _nodes - the nodes that have just arrived
    */
   updatePositions(t) {
-    for (let e = 0; e < U; e++) {
+    for (let e = 0; e < V; e++) {
       if (this.isSettled)
         return;
       this.step();
@@ -615,7 +617,7 @@ const E = class E {
    * freeze counts as placed, which is what makes a file's own coordinates yield to it.
    *
    * A PINNED ROW REFUSES A LAYOUT STEP. This is the whole of "a pin is meaningful under every
-   * arrangement": twelve of the element's seventeen engines implement `pin()` as a no-op and
+   * arrangement": fourteen of the element's nineteen engines implement `pin()` as a no-op and
    * `setNodePosition` as a no-op too, so before this guard a reader who dragged a node under a
    * static layout watched it snap back the next time the layout recomputed. One refusal here
    * covers every engine, including one written by a third party that has never heard of pinning,
@@ -682,7 +684,7 @@ const E = class E {
     for (const a of t) {
       const c = a.index >= 0 && a.index < s.length ? s[a.index] : 1;
       c !== 1 && (n = !0);
-      const I = G(a.srcId, a.dstId);
+      const I = U(a.srcId, a.dstId);
       r.set(I, (r.get(I) ?? 0) + c);
     }
     return n ? r : null;
@@ -703,7 +705,7 @@ const E = class E {
     let s = 0;
     for (const r of e.values())
       r < P && s++;
-    s > 0 && W.warn("Edge weights at or below zero were clamped before the layout read them", {
+    s > 0 && G.warn("Edge weights at or below zero were clamped before the layout read them", {
       layout: t,
       clamped: s,
       epsilon: P
@@ -744,7 +746,7 @@ const E = class E {
    * offered by a picker, described in a reader's language, or found by `layoutIdForEngine`.
    *
    * A third party's class must declare a `static descriptor` whose `id` equals its
-   * `static type`. The element's own seventeen are the one exemption, because their arrangements
+   * `static type`. The element's own nineteen are the one exemption, because their arrangements
    * are authored centrally in the layout catalogue where several engines may sit behind one
    * public name.
    * @param cls - The layout engine class.
@@ -764,7 +766,7 @@ const E = class E {
       });
     if (l.get(s) === t)
       return t;
-    const n = C.includes(s);
+    const n = W.includes(s);
     if (r === void 0) {
       if (!n)
         throw new g({
@@ -773,7 +775,7 @@ const E = class E {
           source: "registry",
           details: { kind: "layout", name: s, field: "descriptor" }
         });
-      if (l.has(s))
+      if (l.hasOwn(s))
         throw A(s);
       return l.set(s, t), t;
     }
@@ -786,7 +788,7 @@ const E = class E {
         source: "registry",
         details: { kind: "layout", name: s, field: "descriptor.id", id: r.id }
       });
-    return z({
+    return B({
       descriptor: { ...r, honoursWeights: e.honoursWeights ?? !1 },
       type: s
     }), l.set(s, t), t;
@@ -851,17 +853,17 @@ const E = class E {
 };
 E.honoursWeights = !1;
 let w = E;
-const V = O.looseObject({
+const X = O.looseObject({
   scalingFactor: O.number().default(100)
 });
-class dt extends w {
+class ut extends w {
   /**
    * Create a simple layout engine
    * @param opts - Configuration options including scalingFactor
    */
   constructor(t = {}) {
     super(), this._nodes = [], this._edges = [], this.stale = !0, this.positions = {}, this.scalingFactor = 100, this.isSettled = !0;
-    const e = V.parse(t);
+    const e = X.parse(t);
     this.scalingFactor = e.scalingFactor;
   }
   /**
@@ -1050,37 +1052,37 @@ class dt extends w {
    */
   publishedOr(t, e) {
     const s = { x: 0, y: 0, z: 0 };
-    return t !== void 0 && this.readNodePosition(t, s) ? s : X(this.positions[e], this.scalingFactor);
+    return t !== void 0 && this.readNodePosition(t, s) ? s : K(this.positions[e], this.scalingFactor);
   }
 }
-function X(i, t) {
+function K(i, t) {
   if (!i || i.length === 0)
     return { x: 0, y: 0, z: 0 };
   const e = i[0] * t, s = i[1] * t, r = (i[2] ?? 0) * t;
   return { x: e, y: s, z: r };
 }
-const K = /^#[0-9a-f]{6}$/i;
+const H = /^#[0-9a-f]{6}$/i;
 function q(i) {
   if (typeof i != "string" || i.trim() === "")
     return null;
   try {
-    const t = v(i.trim());
+    const t = L(i.trim());
     if (t === void 0)
       return null;
     const e = t.length === 9 ? t.slice(0, 7) : t;
-    return K.test(e) ? e.toUpperCase() : null;
+    return H.test(e) ? e.toUpperCase() : null;
   } catch {
     return null;
   }
 }
-function H(i) {
+function J(i) {
   return JSON.stringify([i.id, i.kind, i.colors, i.capacity, i.colorblindSafe]);
 }
 const y = b({
   kind: "palette",
   idOf: (i) => i.id,
   descriptorOf: (i) => i,
-  implementationOf: H,
+  implementationOf: J,
   builtInIds: () => k
 });
 function u(i, t, e) {
@@ -1091,7 +1093,7 @@ function u(i, t, e) {
     details: { kind: "palette", name: typeof i == "string" ? i : "", field: t }
   });
 }
-function ut(i, t) {
+function pt(i, t) {
   typeof i != "object" && u("", "descriptor", "registerPalette takes a palette descriptor"), (i.plainName === void 0 || i.plainName === "") && u(i.id, "plainName", `the palette "${String(i.id)}" was registered without a plain name`), i.kind !== "sequential" && i.kind !== "diverging" && i.kind !== "categorical" && u(
     i.id,
     "kind",
@@ -1117,13 +1119,13 @@ function ut(i, t) {
     t
   );
 }
-function pt() {
+function gt() {
   return y.descriptors();
 }
-function gt(i) {
+function ft(i) {
   return y.byId(i);
 }
-function ft() {
+function mt() {
   y.clearForTesting();
 }
 export {
@@ -1131,23 +1133,23 @@ export {
   _ as F,
   w as L,
   o as P,
-  V as S,
-  nt as U,
+  X as S,
+  ot as U,
   P as W,
-  dt as a,
-  ht as b,
-  rt as c,
-  ft as d,
-  L as e,
-  lt as f,
-  pt as g,
-  st as h,
-  ot as i,
-  at as j,
-  G as k,
-  ct as l,
-  gt as m,
+  ut as a,
+  dt as b,
+  nt as c,
+  mt as d,
+  $ as e,
+  ct as f,
+  gt as g,
+  rt as h,
+  at as i,
+  lt as j,
+  U as k,
+  ht as l,
+  ft as m,
   d as n,
-  it as p,
-  ut as r
+  st as p,
+  pt as r
 };

package/dist/chunks/pluginRegistry-MaTIDh6l.js

@@ -0,0 +1,238 @@
+const N = {
+  E_BAD_COMMAND: "E_BAD_COMMAND",
+  E_BAD_QUERY: "E_BAD_QUERY",
+  E_BAD_LAYER: "E_BAD_LAYER",
+  E_BAD_SELECTOR: "E_BAD_SELECTOR",
+  E_BAD_FORMULA: "E_BAD_FORMULA",
+  E_SELECTOR_EMPTY: "E_SELECTOR_EMPTY",
+  E_UNSCOPED_RUN_ENCODING: "E_UNSCOPED_RUN_ENCODING",
+  E_UNKNOWN_SCALE: "E_UNKNOWN_SCALE",
+  E_UNKNOWN_CHANNEL: "E_UNKNOWN_CHANNEL",
+  E_UNKNOWN_OPTION: "E_UNKNOWN_OPTION",
+  E_OPTION_RANGE: "E_OPTION_RANGE",
+  E_UNKNOWN_ATTRIBUTE: "E_UNKNOWN_ATTRIBUTE",
+  E_UNKNOWN_ALGORITHM: "E_UNKNOWN_ALGORITHM",
+  E_UNKNOWN_LAYOUT: "E_UNKNOWN_LAYOUT",
+  E_UNKNOWN_FORMAT: "E_UNKNOWN_FORMAT",
+  E_UNKNOWN_PALETTE: "E_UNKNOWN_PALETTE",
+  E_UNKNOWN_CAMERA: "E_UNKNOWN_CAMERA",
+  E_UNKNOWN_SINK: "E_UNKNOWN_SINK",
+  E_UNKNOWN_RUN: "E_UNKNOWN_RUN",
+  E_UNSTABLE_RUN_ID: "E_UNSTABLE_RUN_ID",
+  E_DUPLICATE_ID: "E_DUPLICATE_ID",
+  E_DUPLICATE_EDGE: "E_DUPLICATE_EDGE",
+  E_DUPLICATE_PLUGIN: "E_DUPLICATE_PLUGIN",
+  E_PROTECTED: "E_PROTECTED",
+  E_FETCH_FAILED: "E_FETCH_FAILED",
+  E_PARSE_FAILED: "E_PARSE_FAILED",
+  E_EDGE_ENDPOINTS_UNRESOLVED: "E_EDGE_ENDPOINTS_UNRESOLVED",
+  E_ID_MISSING: "E_ID_MISSING",
+  E_EMPTY_LOAD: "E_EMPTY_LOAD",
+  E_SUPERSEDED: "E_SUPERSEDED",
+  E_TOO_LARGE: "E_TOO_LARGE",
+  E_OUT_OF_MEMORY: "E_OUT_OF_MEMORY",
+  E_CAP_EXCEEDED: "E_CAP_EXCEEDED",
+  E_SCOPE_EMPTY: "E_SCOPE_EMPTY",
+  E_NOT_CONVERGED: "E_NOT_CONVERGED",
+  E_NO_ACCELERATOR: "E_NO_ACCELERATOR",
+  E_NO_WEBGPU: "E_NO_WEBGPU",
+  E_NO_ADAPTER: "E_NO_ADAPTER",
+  E_SOFTWARE_ONLY: "E_SOFTWARE_ONLY",
+  E_DEVICE_INCORRECT: "E_DEVICE_INCORRECT",
+  E_DEVICE_LOST: "E_DEVICE_LOST",
+  E_NO_WEBGL: "E_NO_WEBGL",
+  E_UNSUPPORTED: "E_UNSUPPORTED",
+  E_READONLY: "E_READONLY",
+  E_DISPOSED: "E_DISPOSED",
+  E_INTERNAL: "E_INTERNAL"
+}, T = Object.freeze(Object.values(N)), D = Object.freeze([
+  N.E_NO_WEBGPU,
+  N.E_NO_ADAPTER,
+  N.E_SOFTWARE_ONLY,
+  N.E_DEVICE_INCORRECT,
+  N.E_DEVICE_LOST,
+  N.E_TOO_LARGE
+]);
+function i(e) {
+  return typeof e == "string" && Object.hasOwn(N, e);
+}
+const d = Object.freeze({});
+function A(e) {
+  if (typeof e != "object" || e === null || !("code" in e))
+    return;
+  const { code: E } = e;
+  return i(E) ? E : void 0;
+}
+function c(e) {
+  if (typeof e != "object" || e === null || !("code" in e))
+    return;
+  const { code: E } = e;
+  return typeof E == "string" && !i(E) ? E : void 0;
+}
+class O extends Error {
+  /**
+   * Builds an error.
+   * @param init - The code, the message, the failing area and anything else known about the
+   * failure.
+   */
+  constructor(E) {
+    super(E.message, E.cause === void 0 ? void 0 : { cause: E.cause }), this.name = "GraphtyError", Object.setPrototypeOf(this, new.target.prototype), this.code = E.code, this.source = E.source, this.recoverable = E.recoverable ?? !1, this.details = E.details === void 0 ? d : Object.freeze({ ...E.details }), E.target !== void 0 && (this.target = E.target);
+  }
+  /**
+   * Re-reports a failure from somewhere else as a `GraphtyError`.
+   *
+   * A sibling package -- graph-io, graph-format, the WebGPU peer -- throws its own class. The
+   * class does not cross the boundary, so the element carries the code instead: when the
+   * original's `code` is one the element knows, that code wins; when it is a string the
+   * element does not know, it is kept in `details.sourceCode` and the caller's code is used.
+   * A value that is already a `GraphtyError` is returned untouched, so the most specific code
+   * survives.
+   * @param cause - The thrown value being wrapped.
+   * @param init - The code, area and facts to use when the original supplies none.
+   * @returns The error to throw.
+   */
+  static wrap(E, _) {
+    if (E instanceof O)
+      return E;
+    const r = A(E), s = c(E), n = _.message ?? (E instanceof Error ? E.message : String(E)), t = s === void 0 ? _.details : { ..._.details, sourceCode: s };
+    return new O({
+      ..._,
+      code: r ?? _.code,
+      message: n,
+      details: t,
+      cause: E
+    });
+  }
+  /**
+   * Renders the error as plain JSON.
+   *
+   * Called by `JSON.stringify`, and used wherever an error has to survive a boundary a class
+   * cannot cross: a log line, a worker message, a bug report.
+   * @returns The serialisable form.
+   */
+  toJSON() {
+    const E = {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      source: this.source,
+      recoverable: this.recoverable,
+      details: this.details
+    };
+    return this.target !== void 0 && (E.target = this.target), this.cause instanceof Error && (E.causeMessage = this.cause.message), E;
+  }
+}
+function R(e) {
+  return e instanceof O;
+}
+function a(e, E) {
+  const _ = globalThis, r = /* @__PURE__ */ Symbol.for(`graphty.registry.v1.${e}`);
+  return _[r] ??= E(), _[r];
+}
+class U {
+  #E = /* @__PURE__ */ new Map();
+  #e;
+  /**
+   * Join the page's shared map for this extension point, creating it if this copy is first.
+   * @param kind - Which extension point, which names the page's shared map.
+   */
+  constructor(E) {
+    this.#e = a(`${E}-implementations`, () => /* @__PURE__ */ new Map());
+  }
+  /**
+   * File an implementation for this copy and for every other copy on the page.
+   * @param name - The name it is filed under.
+   * @param value - The implementation.
+   */
+  set(E, _) {
+    this.#E.set(E, _), this.#e.set(E, _);
+  }
+  /**
+   * This copy's implementation, or else the one another copy filed.
+   * @param name - The name.
+   * @returns The implementation, or undefined when no copy filed one.
+   */
+  get(E) {
+    return this.#E.get(E) ?? this.#e.get(E);
+  }
+  /**
+   * Whether THIS copy filed the name, which is what a built-in duplicate check asks: another
+   * copy registering its own built-ins is not a collision.
+   * @param name - The name.
+   * @returns True when this copy filed it.
+   */
+  hasOwn(E) {
+    return this.#E.has(E);
+  }
+  /**
+   * Every name any copy filed.
+   * @returns The names, this copy's first.
+   */
+  keys() {
+    return (/* @__PURE__ */ new Set([...this.#E.keys(), ...this.#e.keys()])).values();
+  }
+}
+function C(e) {
+  const E = a(e.kind, () => ({
+    entries: /* @__PURE__ */ new Map(),
+    warned: /* @__PURE__ */ new Set(),
+    cached: null
+  })), { entries: _, warned: r } = E;
+  return {
+    register(s, n) {
+      const t = e.idOf(s);
+      if (typeof t != "string" || t === "")
+        throw new O({
+          code: "E_BAD_COMMAND",
+          message: `a ${e.kind} registration needs an id`,
+          source: "registry",
+          details: { kind: e.kind, field: "id" }
+        });
+      if (e.builtInIds().includes(t))
+        throw new O({
+          code: "E_DUPLICATE_PLUGIN",
+          message: `"${t}" is the id of a ${e.kind} the element ships, and a built-in id may not be taken: a saved document that named it yesterday has to mean the same thing today`,
+          source: "registry",
+          details: { kind: e.kind, name: t, builtIn: !0 }
+        });
+      const o = _.get(t);
+      if (o !== void 0) {
+        if (e.implementationOf(o) === e.implementationOf(s))
+          return;
+        if (n?.strict === !0)
+          throw new O({
+            code: "E_DUPLICATE_PLUGIN",
+            message: `a ${e.kind} named "${t}" is already registered`,
+            source: "registry",
+            details: { kind: e.kind, name: t }
+          });
+        r.has(t) || (r.add(t), console.warn(
+          `graphty: a second ${e.kind} named "${t}" replaced the first. Register one implementation per name, or pass { strict: true } to make this throw.`
+        ));
+      }
+      _.set(t, s), E.cached = null;
+    },
+    entries() {
+      return Object.freeze([..._.values()]);
+    },
+    descriptors() {
+      return E.cached ??= Object.freeze([..._.values()].map((s) => e.descriptorOf(s))), E.cached;
+    },
+    byId(s) {
+      return _.get(s);
+    },
+    clearForTesting() {
+      _.clear(), r.clear(), E.cached = null;
+    }
+  };
+}
+export {
+  D as A,
+  O as G,
+  U as S,
+  T as a,
+  i as b,
+  C as c,
+  R as i,
+  a as s
+};

package/dist/chunks/{registry-CSba5QGJ.js → registry-DQeq4B2K.js}

@@ -1,5 +1,5 @@
-import { G as a } from "./GraphtyError-BwcnblTH.js";
-class n {
+import { s as n, G as a } from "./pluginRegistry-MaTIDh6l.js";
+class c {
   #e = /* @__PURE__ */ new Map();
   #t = /* @__PURE__ */ new Set();
   #a = /* @__PURE__ */ new Set();
@@ -102,12 +102,12 @@ class n {
       e();
   }
 }
-const c = new n();
-function i(r, e) {
-  c.register(r, e);
+const o = n("accelerator", () => new c());
+function h(r, e) {
+  o.register(r, e);
 }
 export {
-  n as A,
-  c as a,
-  i as r
+  c as A,
+  o as a,
+  h as r
 };