@graphty/graphty-element 2.0.1 → 2.2.0

package/README.md

@@ -1,10 +1,10 @@
 # @graphty/graphty-element
 
 [![npm version](https://img.shields.io/npm/v/@graphty/graphty-element.svg)](https://www.npmjs.com/package/@graphty/graphty-element)
-[![CI/CD](https://github.com/graphty-org/graphty-element/actions/workflows/ci.yml/badge.svg)](https://github.com/graphty-org/graphty-element/actions/workflows/ci.yml)
+[![CI/CD](https://github.com/graphty-org/graphty-monorepo/actions/workflows/ci.yml/badge.svg)](https://github.com/graphty-org/graphty-monorepo/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/graphty-org/graphty-element/badge.svg?branch=master)](https://coveralls.io/github/graphty-org/graphty-element?branch=master)
 [![Documentation](https://img.shields.io/badge/docs-vitepress-blue)](https://graphty.app/docs/graphty-element/)
-[![Storybook](https://img.shields.io/badge/storybook-examples-ff4785)](https://graphty.app/storybook/element/)
+[![Storybook](https://img.shields.io/badge/storybook-examples-ff4785)](https://graphty.app/storybook/graphty-element/)
 
 A Web Component for 3D/2D graph visualization built with Lit and Babylon.js.
 
@@ -52,7 +52,7 @@ npm install @graphty/graphty-element @babylonjs/core lit
 - [Getting Started Guide](https://graphty.app/docs/graphty-element/guide/getting-started)
 - [Installation](https://graphty.app/docs/graphty-element/guide/installation)
 - [API Reference](https://graphty.app/docs/graphty-element/api/)
-- [Interactive Examples (Storybook)](https://graphty.app/storybook/element/)
+- [Interactive Examples (Storybook)](https://graphty.app/storybook/graphty-element/)
 
 ## Features
 

package/dist/ai.js

@@ -1,9 +1,9 @@
-import { f as p } from "./chunks/AiManager-awS0MNr1.js";
-import { A as L, a as M, b as D, C as V, M as j, S as E, c as z, V as N, d as q, e as W, g as G, h as T, i as F, j as U, k as _, l as B, m as J, q as O, s as Y, n as H, o as Q, p as K, r as X, z as Z } from "./chunks/AiManager-awS0MNr1.js";
+import { f as p } from "./chunks/AiManager-DWwQiBQu.js";
+import { A as L, a as M, b as D, C as V, M as j, S as E, c as z, V as N, d as q, e as W, g as G, h as T, i as F, j as U, k as _, l as B, m as J, q as O, s as Y, n as H, o as Q, p as K, r as X, z as Z } from "./chunks/AiManager-DWwQiBQu.js";
 import { A as te } from "./chunks/ApiKeyManager-C0ac91dE.js";
-import { V as se } from "./chunks/VoiceInputAdapter-CcnCmxo5.js";
+import { V as se } from "./chunks/VoiceInputAdapter-mD0x3z7t.js";
 import { z as r } from "zod";
-import { A as u } from "./chunks/Algorithm-BdcqHKps.js";
+import { A as u } from "./chunks/Algorithm-RQ629NLb.js";
 const m = r.object({
   namespace: r.string().describe("The namespace of the algorithm (e.g., 'graphty')"),
   type: r.string().describe("The type of algorithm to run (e.g., 'degree', 'pagerank')")

package/dist/catalog.js

@@ -1,8 +1,8 @@
-import { B as y, L as f, a as m, P as T, S, U as v, b as O, c as E, l as A, d as N, e as I, p as R, f as k, s as x, g as _ } from "./chunks/scales-DvGid5Ln.js";
-import { C, a as L, b as P, c as W, d as U, e as F, f as B } from "./chunks/cameras-BeIAlMWR.js";
-import { d as M, a as K } from "./chunks/detect-B-YbbP7i.js";
-import { F as Y, U as G, t as z, u as V, o as q } from "./chunks/paletteRegistry-B-oS4YxP.js";
-import { L as Z, l as $ } from "./chunks/GraphtyLogger-CK03SnJi.js";
+import { B as y, L as f, a as m, P as T, S, U as v, b as O, c as E, l as A, d as N, e as I, p as R, f as k, s as x, g as _ } from "./chunks/scales-BUS7NWy2.js";
+import { C, a as L, b as P, c as W, d as U, e as F, f as B } from "./chunks/cameras-DFXNYBze.js";
+import { d as M, a as K } from "./chunks/detect-CqN0mC6u.js";
+import { F as Y, U as G, t as z, u as V, o as q } from "./chunks/paletteRegistry-NrWOKT-A.js";
+import { L as Z, l as $ } from "./chunks/GraphtyLogger-5KEttFUo.js";
 import { A as Q, C as ee, f as te, K as ae, a as oe, b as ne, c as re, d as ie, g as se, O as he, R as le, h as de, j as ce, k as we, i as ue, e as pe } from "./chunks/types-B7bX5c0K.js";
 const d = Object.keys({
   enabled: 0,

package/dist/chunks/{AiManager-awS0MNr1.js → AiManager-DWwQiBQu.js}

@@ -1,11 +1,11 @@
-import { l as _ } from "./VoiceInputAdapter-CcnCmxo5.js";
-import { G as K } from "./GraphtyLogger-CK03SnJi.js";
+import { l as _ } from "./VoiceInputAdapter-mD0x3z7t.js";
+import { G as K } from "./GraphtyLogger-5KEttFUo.js";
 import W from "jmespath";
 import { z as m } from "zod";
-import { e as G } from "./Algorithm-BdcqHKps.js";
-import { N as H, c as B, C as X } from "./cameras-BeIAlMWR.js";
+import { e as G } from "./Algorithm-RQ629NLb.js";
+import { N as H, c as B, C as X } from "./cameras-DFXNYBze.js";
 import { inferSchema as C } from "@jsonhero/schema-infer";
-import { i as Z } from "./GraphtyError-B3eKs4yg.js";
+import { i as Z } from "./GraphtyError-BwcnblTH.js";
 import { createAnthropic as Y } from "@ai-sdk/anthropic";
 import { createGoogleGenerativeAI as J } from "@ai-sdk/google";
 import { createOpenAI as Q } from "@ai-sdk/openai";

package/dist/chunks/{Algorithm-BdcqHKps.js → Algorithm-RQ629NLb.js}

@@ -1,15 +1,16 @@
-import { q as f } from "./GraphtyLogger-CK03SnJi.js";
-import { K as O, f as $ } from "./types-B7bX5c0K.js";
-import { G as d } from "./GraphtyError-B3eKs4yg.js";
-import { Graph as S } from "@graphty/algorithms";
-const m = f({
+import { q as C } from "./GraphtyLogger-5KEttFUo.js";
+import { K as $, f as N } from "./types-B7bX5c0K.js";
+import { G as d } from "./GraphtyError-BwcnblTH.js";
+import { Graph as _, accelerated as y } from "@graphty/algorithms";
+import { INVALID_INDEX as w } from "@graphty/graph-format";
+const p = C({
   kind: "camera",
   idOf: (e) => e.descriptor.id,
   descriptorOf: (e) => e.descriptor,
   implementationOf: (e) => e.compute,
-  builtInIds: () => O
+  builtInIds: () => $
 });
-function R(e, t) {
+function K(e, t) {
   const s = e.descriptor;
   if (s === void 0 || typeof s != "object")
     throw new d({
@@ -39,25 +40,57 @@ function R(e, t) {
       source: "registry",
       details: { kind: "camera", name: String(s.id), field: "compute" }
     });
-  m.register(e, t);
+  p.register(e, t);
+}
+function z() {
+  return p.descriptors();
+}
+function W(e) {
+  return p.byId(e);
+}
+function Y() {
+  p.clearForTesting();
 }
-function T() {
-  return m.descriptors();
+const I = ["forceAtlas2", "fruchtermanReingold", "springElectrical", "release"], k = [
+  "pageRank",
+  "sssp",
+  "breadthFirstSearch",
+  "connectedComponents",
+  "weaklyConnectedComponents",
+  "minimumSpanningTree"
+];
+function H(e) {
+  const t = {
+    kind: e.backend
+  };
+  for (const s of I) {
+    const r = e[s];
+    typeof r == "function" && (t[s] = r.bind(e));
+  }
+  return t;
 }
-function V(e) {
-  return m.byId(e);
+function R(e) {
+  const t = {
+    kind: e.backend
+  };
+  for (const s of k) {
+    const r = e[s];
+    typeof r == "function" && (t[s] = r.bind(e));
+  }
+  return t;
 }
-function j() {
-  m.clearForTesting();
+const D = ["auto", "off", "required"], Z = "auto";
+function X(e) {
+  return typeof e == "string" && D.includes(e);
 }
-const p = f({
+const M = "f64", J = "f32", Q = "acceleration.minNodes", ee = 0, g = C({
   kind: "algorithm",
   idOf: (e) => e.descriptor.key,
   descriptorOf: (e) => e.descriptor,
   implementationOf: (e) => e.descriptor,
-  builtInIds: () => $
+  builtInIds: () => N
 });
-function A(e, t) {
+function T(e, t) {
   if (e.descriptor.key !== e.type)
     throw new d({
       code: "E_BAD_COMMAND",
@@ -71,18 +104,18 @@ function A(e, t) {
         namespace: e.namespace
       }
     });
-  p.register(e, t);
+  g.register(e, t);
 }
-function x() {
-  return p.descriptors();
+function te() {
+  return g.descriptors();
 }
-function B(e) {
-  return p.byId(e);
+function se(e) {
+  return g.byId(e);
 }
-function G() {
-  p.clearForTesting();
+function re() {
+  g.clearForTesting();
 }
-class o extends Error {
+class a extends Error {
   /**
    * Creates an option validation error
    * @param optionKey - The key of the option that failed validation
@@ -92,93 +125,106 @@ class o extends Error {
     super(`Option '${t}': ${s}`), this.optionKey = t, this.name = "OptionValidationError";
   }
 }
-function k(e, t, s) {
+function v(e, t, s) {
   if (t == null) {
     if (s.required)
-      throw new o(e, "is required but was not provided");
+      throw new a(e, "is required but was not provided");
     return;
   }
   switch (s.type) {
     case "number":
-      u(e, t, s, !1);
+      A(e, t, s, !1);
       break;
     case "integer":
-      u(e, t, s, !0);
+      A(e, t, s, !0);
       break;
     case "boolean":
       if (typeof t != "boolean")
-        throw new o(e, `must be a boolean, got ${typeof t}`);
+        throw new a(e, `must be a boolean, got ${typeof t}`);
       break;
     case "string":
       if (typeof t != "string")
-        throw new o(e, `must be a string, got ${typeof t}`);
+        throw new a(e, `must be a string, got ${typeof t}`);
       break;
     case "select":
-      N(e, t, s);
+      L(e, t, s);
       break;
     case "nodeId":
       if (typeof t != "string" && typeof t != "number")
-        throw new o(e, `must be a string or number (node ID), got ${typeof t}`);
+        throw new a(e, `must be a string or number (node ID), got ${typeof t}`);
       break;
     default:
-      throw new o(e, `has unknown type '${s.type}'`);
+      throw new a(e, `has unknown type '${s.type}'`);
   }
 }
-function u(e, t, s, r) {
+function A(e, t, s, r) {
   if (typeof t != "number")
-    throw new o(e, `must be a number, got ${typeof t}`);
+    throw new a(e, `must be a number, got ${typeof t}`);
   if (Number.isNaN(t))
-    throw new o(e, "must not be NaN");
+    throw new a(e, "must not be NaN");
   if (!Number.isFinite(t))
-    throw new o(e, "must be finite");
+    throw new a(e, "must be finite");
   if (r && !Number.isInteger(t))
-    throw new o(e, `must be an integer, got ${t}`);
+    throw new a(e, `must be an integer, got ${t}`);
   if (s.min !== void 0 && t < s.min)
-    throw new o(e, `must be >= ${s.min}, got ${t}`);
+    throw new a(e, `must be >= ${s.min}, got ${t}`);
   if (s.max !== void 0 && t > s.max)
-    throw new o(e, `must be <= ${s.max}, got ${t}`);
+    throw new a(e, `must be <= ${s.max}, got ${t}`);
 }
-function N(e, t, s) {
+function L(e, t, s) {
   if (!s.options || s.options.length === 0)
-    throw new o(e, "is a select type but has no options defined");
-  if (!s.options.map((i) => i.value).includes(t)) {
-    const i = s.options.map((a) => `'${String(a.value)}'`).join(", ");
-    throw new o(e, `must be one of [${i}], got '${String(t)}'`);
+    throw new a(e, "is a select type but has no options defined");
+  if (!s.options.map((n) => n.value).includes(t)) {
+    const n = s.options.map((i) => `'${String(i.value)}'`).join(", ");
+    throw new a(e, `must be one of [${n}], got '${String(t)}'`);
   }
 }
-function C(e, t) {
+function P(e, t) {
   const s = {};
-  for (const [r, i] of Object.entries(e)) {
-    const c = t?.[r] ?? i.default;
-    k(r, c, i), s[r] = c;
+  for (const [r, n] of Object.entries(e)) {
+    const c = t?.[r] ?? n.default;
+    v(r, c, n), s[r] = c;
   }
   return s;
 }
-function F(e) {
+function ne(e) {
   return e;
 }
-function D(e, t) {
-  const s = e.getSnapshot(), r = t === "directed" ? s : e.undirected(s).snapshot, i = r.flags.multigraph ? r.simplified({ weights: "sum" }).snapshot : r;
-  return _(i, t);
+function x(e, t) {
+  const s = e.getSnapshot(), r = t === "directed" ? s : e.undirected(s).snapshot, n = r.flags.multigraph ? r.simplified({ weights: "sum" }).snapshot : r;
+  return B(n, t);
 }
-function P(e) {
+function oe(e) {
   const t = e.getSnapshot();
   return t.flags.multigraph ? t.edgeCount - t.simplified({ weights: "sum" }).snapshot.edgeCount : 0;
 }
-function _(e, t) {
-  const s = new S({
+function B(e, t) {
+  const s = new _({
     directed: t !== "undirected"
   }), { ids: r } = e;
-  for (let n = 0; n < e.nodeCount; n++)
-    s.addNode(r.idOf(n));
-  const { src: i, dst: a, weights: c } = e.edgeList();
-  for (let n = 0; n < e.edgeCount; n++) {
-    const w = r.idOf(i[n]), b = r.idOf(a[n]), y = c === null ? 1 : c[n];
-    s.addEdge(w, b, y);
+  for (let o = 0; o < e.nodeCount; o++)
+    s.addNode(r.idOf(o));
+  const { src: n, dst: i, weights: c } = e.edgeList();
+  for (let o = 0; o < e.edgeCount; o++) {
+    const u = r.idOf(n[o]), h = r.idOf(i[o]), l = c === null ? 1 : c[o];
+    s.addEdge(u, h, l);
   }
   return s;
 }
-const g = /* @__PURE__ */ new Map(), h = class h {
+const m = /* @__PURE__ */ new Map();
+function F(e, t) {
+  if (t === null)
+    return e;
+  if (e === null)
+    return t;
+  const s = new Uint32Array(e.length);
+  for (let r = 0; r < e.length; r++) {
+    const n = e[r];
+    s[r] = n === w ? w : t[n];
+  }
+  return s;
+}
+const O = class O {
   /**
    * Getter for schema options
    *
@@ -208,7 +254,71 @@ const g = /* @__PURE__ */ new Map(), h = class h {
    * @returns a freshly built Graph for the algorithm package
    */
   algorithmGraph(t) {
-    return D(this.graph.getDataManager(), t);
+    return x(this.graph.getDataManager(), t);
+  }
+  /**
+   * The route an algorithm with an accelerated implementation takes.
+   *
+   * It is the counterpart of {@link algorithmGraph} for the algorithms `@graphty/algorithms`
+   * can dispatch: instead of copying the snapshot into an object graph, the work runs over the
+   * snapshot itself, on the attached accelerator or on the index-based CPU port, and the adapter
+   * writes one loop over an index-aligned result either way.
+   *
+   * THE DECISION IS TAKEN ONCE, HERE, BEFORE ANY WORK STARTS. The controller answers "the policy
+   * is off", "no accelerator", "below `acceleration.minNodes`" or "this accelerator does not
+   * implement that" up front, and under `acceleration="required"` it throws `E_NO_ACCELERATOR`
+   * rather than answering quietly. After the work has started there is no second decision: a
+   * failure from the accelerator propagates with its code and fails the run, because a number
+   * that silently came from somewhere else is worse than no number.
+   * @param capability - The accelerator member this work would use, such as `"pageRank"`.
+   * @param mode - The shape this algorithm needs; see {@link AlgorithmGraphMode}. `"undirected"`
+   *   takes the snapshot's undirected view, which is what collapses a reciprocal pair into one
+   *   edge.
+   * @returns The snapshot, the edge map onto it, and the runner.
+   * @example
+   * ```ts
+   * const { snapshot, run } = this.accelerated("connectedComponents", "undirected");
+   * const { value, precision } = await run((dispatch, s) => dispatch.connectedComponents(s));
+   * const group = value.labels[snapshot.ids.indexOf(nodeId)];
+   * ```
+   */
+  accelerated(t, s) {
+    const r = this.graph.getDataManager(), n = r.getSnapshot(), i = s === "undirected" ? r.undirected(n) : null, c = i === null ? n : i.snapshot, o = c.flags.multigraph ? c.simplified({ weights: "sum" }) : null, u = o === null ? c : o.snapshot, h = this.graph.acceleration, l = { capability: t, nodeCount: u.nodeCount };
+    return {
+      snapshot: u,
+      edgeRemap: F(i?.edgeRemap ?? null, o?.edgeRemap ?? null),
+      run: async (b) => {
+        const f = await h.run(
+          l,
+          (S) => b(y(R(S)), u)
+        );
+        return f.accelerated ? { value: f.value, precision: f.precision } : { value: await b(y(null), u), precision: M };
+      }
+    };
+  }
+  /**
+   * The dense row of a node the reader named in an option.
+   *
+   * A search takes its source as an id and the snapshot answers in indices, so this is where the
+   * two meet -- and where an id that names no node in the graph is reported as what it is: an
+   * option whose value is outside the permitted range, carrying the option's name and what was
+   * passed, rather than a silent empty result or a search from row zero.
+   * @param snapshot - The graph the work runs over.
+   * @param option - The option the id came from, named in the error.
+   * @param id - The node id the reader gave.
+   * @returns The node's dense row.
+   * @throws A `GraphtyError` with `E_OPTION_RANGE` when the graph has no such node.
+   */
+  nodeIndex(t, s, r) {
+    const n = t.ids.indexOf(r);
+    if (n === w)
+      throw new d({
+        code: "E_OPTION_RANGE",
+        message: `the graph has no node "${String(r)}", so "${s}" names nothing to run from`,
+        source: "run",
+        details: { option: s, value: r }
+      });
+    return n;
   }
   /**
    * Resolves and validates options against the schema
@@ -217,7 +327,7 @@ const g = /* @__PURE__ */ new Map(), h = class h {
    */
   resolveOptions(t) {
     const s = this.constructor.optionsSchema;
-    return Object.keys(s).length === 0 ? {} : C(s, t);
+    return Object.keys(s).length === 0 ? {} : P(s, t);
   }
   /**
    * Gets the algorithm type
@@ -270,14 +380,14 @@ const g = /* @__PURE__ */ new Map(), h = class h {
    * @returns The registered algorithm class
    */
   static register(t) {
-    const s = t, r = String(s.type), i = String(s.namespace), { descriptor: a, cost: c, version: n } = s;
-    return a !== void 0 && A({
-      descriptor: a,
-      namespace: i,
+    const s = t, r = String(s.type), n = String(s.namespace), { descriptor: i, cost: c, version: o } = s;
+    return i !== void 0 && T({
+      descriptor: i,
+      namespace: n,
       type: r,
       ...c === void 0 ? {} : { cost: c },
-      ...n === void 0 ? {} : { version: n }
-    }), g.set(`${i}:${r}`, t), t;
+      ...o === void 0 ? {} : { version: o }
+    }), m.set(`${n}:${r}`, t), t;
   }
   /**
    * Gets an algorithm instance from the registry
@@ -287,9 +397,9 @@ const g = /* @__PURE__ */ new Map(), h = class h {
    * @param options - Optional algorithm-specific options to pass to constructor
    * @returns A new instance of the algorithm, or null if not found
    */
-  static get(t, s, r, i) {
-    const a = g.get(`${s}:${r}`);
-    return a ? new a(t, i) : null;
+  static get(t, s, r, n) {
+    const i = m.get(`${s}:${r}`);
+    return i ? new i(t, n) : null;
   }
   /**
    * Gets an algorithm class from the registry
@@ -298,7 +408,7 @@ const g = /* @__PURE__ */ new Map(), h = class h {
    * @returns The algorithm class, or null if not found
    */
   static getClass(t, s) {
-    return g.get(`${t}:${s}`) ?? null;
+    return m.get(`${t}:${s}`) ?? null;
   }
   /**
    * Get the options schema for this algorithm
@@ -337,7 +447,7 @@ const g = /* @__PURE__ */ new Map(), h = class h {
    */
   static getRegisteredAlgorithms(t) {
     const s = [];
-    for (const r of g.keys())
+    for (const r of m.keys())
       (!t || r.startsWith(`${t}:`)) && s.push(r);
     return s.sort();
   }
@@ -357,20 +467,28 @@ const g = /* @__PURE__ */ new Map(), h = class h {
     return this.getRegisteredAlgorithms();
   }
 };
-h.optionsSchema = {};
-let l = h;
+O.optionsSchema = {};
+let E = O;
 export {
-  l as A,
-  o as O,
-  j as a,
-  x as b,
-  G as c,
-  F as d,
-  T as e,
-  C as f,
-  V as g,
-  B as h,
-  P as m,
-  R as r,
-  k as v
+  E as A,
+  M as C,
+  J as D,
+  a as O,
+  Y as a,
+  te as b,
+  re as c,
+  ne as d,
+  z as e,
+  P as f,
+  D as g,
+  Z as h,
+  X as i,
+  W as j,
+  ee as k,
+  Q as l,
+  se as m,
+  H as n,
+  oe as o,
+  K as r,
+  v
 };

package/dist/chunks/{DataSource-DK4GZBKg.js → DataSource-DEg3igzS.js}

@@ -1,8 +1,8 @@
 import { z as p } from "zod/v4";
 import * as $ from "zod/v4/core";
-import { F as w, v as E } from "./paletteRegistry-B-oS4YxP.js";
-import { b as F } from "./GraphtyLogger-CK03SnJi.js";
-import { G as f } from "./GraphtyError-B3eKs4yg.js";
+import { F as w, v as E } from "./paletteRegistry-NrWOKT-A.js";
+import { b as F } from "./GraphtyLogger-5KEttFUo.js";
+import { G as f } from "./GraphtyError-BwcnblTH.js";
 class C {
   /**
    * Creates a new ErrorAggregator instance.