@graphty/graphty-element 2.3.0 → 2.4.0

package/dist/chunks/cameras-ii4vngYY.js

@@ -1,435 +0,0 @@
-import { c as y } from "./common-DWNKjpH_.js";
-import { N as b, E as g } from "./NodeStyle-DKj7HjMJ.js";
-import { j as f, e as N } from "./Algorithm-RQ629NLb.js";
-var L = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
-function z(e) {
-  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
-}
-const T = /^#?(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
-function s(e) {
-  return Number.isFinite(e) ? Math.max(0, Math.min(255, Math.round(e))) : 0;
-}
-function i(e) {
-  return e.toString(16).padStart(2, "0");
-}
-function S(e) {
-  if (!T.test(e))
-    return null;
-  const a = e.startsWith("#") ? e.slice(1) : e, t = a.length <= 4, n = (r) => {
-    const m = t ? a[r].repeat(2) : a.slice(r * 2, r * 2 + 2);
-    return parseInt(m, 16);
-  }, o = a.length === 4 || a.length === 8;
-  return {
-    r: n(0),
-    g: n(1),
-    b: n(2),
-    a: o ? n(3) / 255 : 1
-  };
-}
-function _(e) {
-  return typeof e != "object" || e === null || !("hex" in e) ? null : e;
-}
-function P(e) {
-  if (e == null)
-    return null;
-  if (typeof e == "object")
-    return c(e);
-  const a = S(e);
-  if (a !== null)
-    return c(a);
-  try {
-    const t = y(e);
-    return t === void 0 ? null : P(t);
-  } catch {
-    return null;
-  }
-}
-function c(e) {
-  const a = s(e.r), t = s(e.g), n = s(e.b), o = Number.isFinite(e.a) ? Math.max(0, Math.min(1, e.a)) : 1, r = `#${i(a)}${i(t)}${i(n)}`;
-  return { r: a, g: t, b: n, a: o, hex: o === 1 ? r : `${r}${i(Math.round(o * 255))}` };
-}
-const A = b.options, x = g.shape.line.unwrap().shape.type.unwrap().options, h = g.shape.arrowHead.unwrap().shape.type.unwrap().unwrap().options, C = "An outline has a colour and no width. Babylon draws it with a highlight LAYER, and the stroke's blur size belongs to that layer rather than to a mesh, so every outline on screen is drawn at one width whatever a style asks for -- which is why the node style declares no outline width to ask with. The outline's COLOUR is per style; a width per style would need one highlight layer per width, at a full-screen pass each.", d = 'A caption hangs from the cap at that end of the edge, so an end drawn with no arrow carries none: a tail caption needs `edge.arrowTail` set to something other than "none". The words are what switch a caption on, so a layer that writes only the caption\'s appearance and no words draws nothing, exactly as `node.labelStyle` draws nothing without `node.label`.', p = "A tooltip is drawn on hover and only on hover, so a graph at rest shows none: a layer that writes one changes nothing until a reader points at the node. The words are what switch it on, so a layer that writes only the tooltip's appearance and no words draws nothing, exactly as `node.labelStyle` draws nothing without `node.label`. Only a NODE has a tooltip; `edge.tooltip` was withdrawn in 2.0 because an edge cannot be hovered.", l = {
-  "node.color": {
-    channel: "node.color",
-    target: "node",
-    plainName: "Node Colour",
-    accepts: "color",
-    stylePath: "texture.color",
-    renderable: !0
-  },
-  "node.size": {
-    channel: "node.size",
-    target: "node",
-    plainName: "Node Size",
-    accepts: "number",
-    min: 0,
-    stylePath: "shape.size",
-    renderable: !0
-  },
-  "node.shape": {
-    channel: "node.shape",
-    target: "node",
-    plainName: "Node Shape",
-    accepts: "enum",
-    values: A,
-    stylePath: "shape.type",
-    renderable: !0
-  },
-  "node.label": {
-    channel: "node.label",
-    target: "node",
-    plainName: "Node Label",
-    accepts: "text",
-    stylePath: "label.text",
-    renderable: !0
-  },
-  "node.labelStyle": {
-    channel: "node.labelStyle",
-    target: "node",
-    plainName: "Node Label Style",
-    accepts: "labelStyle",
-    stylePath: "label",
-    renderable: !0
-  },
-  "node.tooltip": {
-    channel: "node.tooltip",
-    target: "node",
-    plainName: "Node Tooltip",
-    accepts: "text",
-    stylePath: "tooltip.text",
-    renderable: !0,
-    caveat: p
-  },
-  "node.tooltipStyle": {
-    channel: "node.tooltipStyle",
-    target: "node",
-    plainName: "Node Tooltip Style",
-    accepts: "labelStyle",
-    stylePath: "tooltip",
-    renderable: !0,
-    caveat: p
-  },
-  "node.opacity": {
-    channel: "node.opacity",
-    target: "node",
-    plainName: "Node Opacity",
-    accepts: "number",
-    min: 0,
-    max: 1,
-    stylePath: "texture.color.opacity",
-    renderable: !0
-  },
-  "node.outline": {
-    channel: "node.outline",
-    target: "node",
-    plainName: "Node Outline",
-    accepts: "color",
-    stylePath: "effect.outline.color",
-    renderable: !0,
-    caveat: C
-  },
-  "node.glow": {
-    channel: "node.glow",
-    target: "node",
-    plainName: "Node Glow",
-    accepts: "color",
-    stylePath: "effect.glow.color",
-    renderable: !0
-  },
-  "node.glowStrength": {
-    channel: "node.glowStrength",
-    target: "node",
-    plainName: "Node Glow Strength",
-    accepts: "number",
-    min: 0,
-    stylePath: "effect.glow.strength",
-    renderable: !0
-  },
-  "node.wireframe": {
-    channel: "node.wireframe",
-    target: "node",
-    plainName: "Node Wireframe",
-    accepts: "boolean",
-    stylePath: "effect.wireframe",
-    renderable: !0
-  },
-  "node.flat": {
-    channel: "node.flat",
-    target: "node",
-    plainName: "Node Flat Shading",
-    accepts: "boolean",
-    stylePath: "effect.flatShaded",
-    renderable: !0
-  },
-  "node.marker": {
-    channel: "node.marker",
-    target: "node",
-    plainName: "Node Marker",
-    accepts: "nothing",
-    stylePath: "texture.icon",
-    renderable: !1,
-    caveat: "The element draws no marker. texture.icon is in the node schema and no renderer reads it, and the badge vocabulary belongs to a label rather than to a node."
-  },
-  "edge.color": {
-    channel: "edge.color",
-    target: "edge",
-    plainName: "Edge Colour",
-    accepts: "color",
-    stylePath: "line.color",
-    renderable: !0
-  },
-  "edge.width": {
-    channel: "edge.width",
-    target: "edge",
-    plainName: "Edge Width",
-    accepts: "number",
-    min: 0,
-    stylePath: "line.width",
-    renderable: !0
-  },
-  "edge.opacity": {
-    channel: "edge.opacity",
-    target: "edge",
-    plainName: "Edge Opacity",
-    accepts: "number",
-    min: 0,
-    max: 1,
-    stylePath: "line.opacity",
-    renderable: !0
-  },
-  "edge.style": {
-    channel: "edge.style",
-    target: "edge",
-    plainName: "Edge Line Pattern",
-    accepts: "enum",
-    values: x,
-    stylePath: "line.type",
-    renderable: !0
-  },
-  "edge.patternCount": {
-    channel: "edge.patternCount",
-    target: "edge",
-    plainName: "Edge Pattern Count",
-    accepts: "number",
-    min: 2,
-    stylePath: "line.patternCount",
-    renderable: !0,
-    caveat: "A cap on how many dots or dashes a patterned edge draws, and it applies to a patterned line only: a solid line has no elements to count, and zigzag and sinewave always tile the whole edge, so they ignore it. Left unset, the spacing rule decides, so a long edge or a thin one draws more of them."
-  },
-  "edge.curvature": {
-    channel: "edge.curvature",
-    target: "edge",
-    plainName: "Edge Curve",
-    accepts: "boolean",
-    stylePath: "line.bezier",
-    renderable: !0,
-    caveat: "A switch, not an amount: the renderer offsets its control points by a fixed fraction of the edge's length, so how far an edge bows cannot be set."
-  },
-  "edge.arrowHead": {
-    channel: "edge.arrowHead",
-    target: "edge",
-    plainName: "Arrow Head",
-    accepts: "enum",
-    values: h,
-    stylePath: "arrowHead.type",
-    renderable: !0
-  },
-  "edge.arrowHeadSize": {
-    channel: "edge.arrowHeadSize",
-    target: "edge",
-    plainName: "Arrow Head Size",
-    accepts: "number",
-    min: 0,
-    stylePath: "arrowHead.size",
-    renderable: !0
-  },
-  "edge.arrowHeadColor": {
-    channel: "edge.arrowHeadColor",
-    target: "edge",
-    plainName: "Arrow Head Colour",
-    accepts: "color",
-    stylePath: "arrowHead.color",
-    renderable: !0
-  },
-  "edge.arrowHeadOpacity": {
-    channel: "edge.arrowHeadOpacity",
-    target: "edge",
-    plainName: "Arrow Head Opacity",
-    accepts: "number",
-    min: 0,
-    max: 1,
-    stylePath: "arrowHead.opacity",
-    renderable: !0
-  },
-  "edge.arrowHeadText": {
-    channel: "edge.arrowHeadText",
-    target: "edge",
-    plainName: "Arrow Head Caption",
-    accepts: "text",
-    stylePath: "arrowHead.text.text",
-    renderable: !0,
-    caveat: d
-  },
-  "edge.arrowHeadTextStyle": {
-    channel: "edge.arrowHeadTextStyle",
-    target: "edge",
-    plainName: "Arrow Head Caption Style",
-    accepts: "labelStyle",
-    stylePath: "arrowHead.text",
-    renderable: !0,
-    caveat: d
-  },
-  "edge.arrowTail": {
-    channel: "edge.arrowTail",
-    target: "edge",
-    plainName: "Arrow Tail",
-    accepts: "enum",
-    values: h,
-    stylePath: "arrowTail.type",
-    renderable: !0
-  },
-  "edge.arrowTailSize": {
-    channel: "edge.arrowTailSize",
-    target: "edge",
-    plainName: "Arrow Tail Size",
-    accepts: "number",
-    min: 0,
-    stylePath: "arrowTail.size",
-    renderable: !0
-  },
-  "edge.arrowTailColor": {
-    channel: "edge.arrowTailColor",
-    target: "edge",
-    plainName: "Arrow Tail Colour",
-    accepts: "color",
-    stylePath: "arrowTail.color",
-    renderable: !0
-  },
-  "edge.arrowTailOpacity": {
-    channel: "edge.arrowTailOpacity",
-    target: "edge",
-    plainName: "Arrow Tail Opacity",
-    accepts: "number",
-    min: 0,
-    max: 1,
-    stylePath: "arrowTail.opacity",
-    renderable: !0
-  },
-  "edge.arrowTailText": {
-    channel: "edge.arrowTailText",
-    target: "edge",
-    plainName: "Arrow Tail Caption",
-    accepts: "text",
-    stylePath: "arrowTail.text.text",
-    renderable: !0,
-    caveat: d
-  },
-  "edge.arrowTailTextStyle": {
-    channel: "edge.arrowTailTextStyle",
-    target: "edge",
-    plainName: "Arrow Tail Caption Style",
-    accepts: "labelStyle",
-    stylePath: "arrowTail.text",
-    renderable: !0,
-    caveat: d
-  },
-  "edge.animationSpeed": {
-    channel: "edge.animationSpeed",
-    target: "edge",
-    plainName: "Edge Animation Speed",
-    accepts: "number",
-    min: 0,
-    stylePath: "line.animationSpeed",
-    renderable: !0
-  },
-  "edge.label": {
-    channel: "edge.label",
-    target: "edge",
-    plainName: "Edge Label",
-    accepts: "text",
-    stylePath: "label.text",
-    renderable: !0
-  },
-  "edge.labelStyle": {
-    channel: "edge.labelStyle",
-    target: "edge",
-    plainName: "Edge Label Style",
-    accepts: "labelStyle",
-    stylePath: "label",
-    renderable: !0
-  }
-}, u = Object.keys(l);
-u.filter(
-  (e) => l[e].accepts === "color"
-);
-function E(e) {
-  return typeof e == "string" && Object.hasOwn(l, e);
-}
-function D(e) {
-  return E(e) ? l[e] : void 0;
-}
-function R(e) {
-  return u.map((a) => l[a]).filter(
-    (a) => a.target === e
-  );
-}
-const w = Object.freeze([
-  {
-    id: "fitToGraph",
-    plainName: "Fit to graph",
-    description: "Frames every element, from an angle in 3D and straight on in 2D.",
-    modes: ["2d", "3d"],
-    options: []
-  },
-  {
-    id: "topView",
-    plainName: "From above",
-    description: "Looks straight down at the graph. The natural view for a flat arrangement.",
-    modes: ["2d", "3d"],
-    options: []
-  },
-  {
-    id: "sideView",
-    plainName: "From the side",
-    description: "Looks along the x axis, which shows how deep an arrangement is.",
-    modes: ["3d"],
-    options: []
-  },
-  {
-    id: "frontView",
-    plainName: "From the front",
-    description: "Looks along the z axis, straight at the face of the arrangement.",
-    modes: ["3d"],
-    options: []
-  },
-  {
-    id: "isometric",
-    plainName: "Isometric",
-    description: "The classic three-quarter view: 45 degrees around and about 35 degrees up.",
-    modes: ["3d"],
-    options: []
-  }
-]);
-function k(e) {
-  return w.find((a) => a.id === e) ?? f(e)?.descriptor;
-}
-function F(e) {
-  return [...w, ...N()].filter(
-    (a) => a.modes.includes(e)
-  );
-}
-export {
-  w as C,
-  C as N,
-  u as a,
-  l as b,
-  k as c,
-  F as d,
-  D as e,
-  R as f,
-  L as g,
-  z as h,
-  E as i,
-  _ as j,
-  P as t
-};