@legionworks/facet 1.9.0

package/dist/gallery/frame/chunks/markdown-gxye5frz.js

@@ -0,0 +1,65 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  TreeViewGrammarGeneratedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-CQNSW5MT.mjs
+var TreeViewValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "TreeViewValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "INDENTATION") {
+      return input?.length || 0;
+    }
+    if (rule.name === "QUOTED_NAME") {
+      return input.substring(1, input.length - 1);
+    }
+    if (rule.name === "BARE_NAME") {
+      return input.replace(/[\t ]+$/, "");
+    }
+    if (rule.name === "CLASS_ANNOTATION") {
+      const trimmed = input.trim();
+      return trimmed.substring(3).trim();
+    }
+    if (rule.name === "ICON_ANNOTATION") {
+      const trimmed = input.trim();
+      return trimmed.substring(5, trimmed.length - 1);
+    }
+    if (rule.name === "DESC_ANNOTATION") {
+      const trimmed = input.trim();
+      return trimmed.substring(2).trim();
+    }
+    return;
+  }
+};
+var TreeViewTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "TreeViewTokenBuilder");
+  }
+  constructor() {
+    super(["treeView-beta"]);
+  }
+};
+var TreeViewModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new TreeViewTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new TreeViewValueConverter, "ValueConverter")
+  }
+};
+function createTreeViewServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const TreeView = inject(createDefaultCoreModule({ shared }), TreeViewGrammarGeneratedModule, TreeViewModule);
+  shared.ServiceRegistry.register(TreeView);
+  return { shared, TreeView };
+}
+__name(createTreeViewServices, "createTreeViewServices");
+
+export { TreeViewModule, createTreeViewServices };

package/dist/gallery/frame/chunks/markdown-h7pzv34e.js

@@ -0,0 +1,105 @@
+import {
+  insertEdge,
+  insertEdgeLabel,
+  markers_default,
+  positionEdgeLabel
+} from "./markdown-s1jatrnk.js";
+import {
+  insertCluster,
+  insertNode,
+  labelHelper
+} from "./markdown-tvdpppw8.js";
+import {
+  interpolateToCurve
+} from "./markdown-ff5wvb43.js";
+import {
+  common_default,
+  getConfig
+} from "./markdown-92n37gd4.js";
+import {
+  log
+} from "./markdown-xw8dsk8b.js";
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+import {
+  __require
+} from "./markdown-809k7q41.js";
+
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-J7OUQ5F2.mjs
+var internalHelpers = {
+  common: common_default,
+  getConfig,
+  insertCluster,
+  insertEdge,
+  insertEdgeLabel,
+  insertMarkers: markers_default,
+  insertNode,
+  interpolateToCurve,
+  labelHelper,
+  log,
+  positionEdgeLabel
+};
+var layoutAlgorithms = {};
+var registerLayoutLoaders = /* @__PURE__ */ __name((loaders) => {
+  for (const loader of loaders) {
+    layoutAlgorithms[loader.name] = loader;
+  }
+}, "registerLayoutLoaders");
+var registerDefaultLayoutLoaders = /* @__PURE__ */ __name(() => {
+  registerLayoutLoaders([
+    {
+      name: "dagre",
+      loader: /* @__PURE__ */ __name(async () => await import("./dagre-VZM6K2ZE-7tyg4yt2.js"), "loader")
+    },
+    {
+      name: "swimlane",
+      loader: /* @__PURE__ */ __name(async () => await import("./swimlanes-SLNWSIFB-e4mxm1gh.js"), "loader")
+    },
+    ...[
+      {
+        name: "cose-bilkent",
+        loader: /* @__PURE__ */ __name(async () => await import("./cose-bilkent-JH36ORCC-sn92qexx.js"), "loader")
+      }
+    ]
+  ]);
+}, "registerDefaultLayoutLoaders");
+registerDefaultLayoutLoaders();
+var render = /* @__PURE__ */ __name(async (data4Layout, svg, positions) => {
+  if (!(data4Layout.layoutAlgorithm in layoutAlgorithms)) {
+    throw new Error(`Unknown layout algorithm: ${data4Layout.layoutAlgorithm}`);
+  }
+  if (data4Layout.diagramId) {
+    for (const node of data4Layout.nodes) {
+      const originalDomId = node.domId || node.id;
+      node.domId = `${data4Layout.diagramId}-${originalDomId}`;
+    }
+  }
+  const layoutDefinition = layoutAlgorithms[data4Layout.layoutAlgorithm];
+  const layoutRenderer = await layoutDefinition.loader();
+  const { theme, themeVariables } = data4Layout.config;
+  const { useGradient, gradientStart, gradientStop } = themeVariables;
+  const svgId = svg.attr("id");
+  svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow`).attr("height", "130%").attr("width", "130%").append("feDropShadow").attr("dx", "4").attr("dy", "4").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
+  svg.append("defs").append("filter").attr("id", `${svgId}-drop-shadow-small`).attr("height", "150%").attr("width", "150%").append("feDropShadow").attr("dx", "2").attr("dy", "2").attr("stdDeviation", 0).attr("flood-opacity", "0.06").attr("flood-color", `${theme?.includes("dark") ? "#FFFFFF" : "#000000"}`);
+  if (useGradient) {
+    const gradient = svg.append("linearGradient").attr("id", svg.attr("id") + "-gradient").attr("gradientUnits", "objectBoundingBox").attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%");
+    gradient.append("svg:stop").attr("offset", "0%").attr("stop-color", gradientStart).attr("stop-opacity", 1);
+    gradient.append("svg:stop").attr("offset", "100%").attr("stop-color", gradientStop).attr("stop-opacity", 1);
+  }
+  return layoutRenderer.render(data4Layout, svg, internalHelpers, {
+    algorithm: layoutDefinition.algorithm
+  }, positions);
+}, "render");
+var getRegisteredLayoutAlgorithm = /* @__PURE__ */ __name((algorithm = "", { fallback = "dagre" } = {}) => {
+  if (algorithm in layoutAlgorithms) {
+    return algorithm;
+  }
+  if (fallback in layoutAlgorithms) {
+    log.warn(`Layout algorithm ${algorithm} is not registered. Using ${fallback} as fallback.`);
+    return fallback;
+  }
+  throw new Error(`Both layout algorithms ${algorithm} and ${fallback} are not registered.`);
+}, "getRegisteredLayoutAlgorithm");
+
+export { registerLayoutLoaders, render, getRegisteredLayoutAlgorithm };

package/dist/gallery/frame/chunks/markdown-hab789t9.js

@@ -0,0 +1,47 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  PieGrammarGeneratedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-YOTPTUD7.mjs
+var PieTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "PieTokenBuilder");
+  }
+  constructor() {
+    super(["pie", "showData"]);
+  }
+};
+var PieValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "PieValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name !== "PIE_SECTION_LABEL") {
+      return;
+    }
+    return input.replace(/"/g, "").trim();
+  }
+};
+var PieModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new PieTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new PieValueConverter, "ValueConverter")
+  }
+};
+function createPieServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const Pie = inject(createDefaultCoreModule({ shared }), PieGrammarGeneratedModule, PieModule);
+  shared.ServiceRegistry.register(Pie);
+  return { shared, Pie };
+}
+__name(createPieServices, "createPieServices");
+
+export { PieModule, createPieServices };

package/dist/gallery/frame/chunks/markdown-hjp6sj8t.js

@@ -0,0 +1,125 @@
+import {
+  require_dist
+} from "./markdown-pzgd8z3s.js";
+import {
+  lineBreakRegex
+} from "./markdown-92n37gd4.js";
+import {
+  select_default
+} from "./markdown-xw8dsk8b.js";
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+import {
+  __toESM
+} from "./markdown-809k7q41.js";
+
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-2GRJ4B5K.mjs
+var import_sanitize_url = __toESM(require_dist(), 1);
+var drawRect = /* @__PURE__ */ __name((element, rectData) => {
+  const rectElement = element.append("rect");
+  rectElement.attr("x", rectData.x);
+  rectElement.attr("y", rectData.y);
+  rectElement.attr("fill", rectData.fill);
+  rectElement.attr("stroke", rectData.stroke);
+  rectElement.attr("width", rectData.width);
+  rectElement.attr("height", rectData.height);
+  if (rectData.name) {
+    rectElement.attr("name", rectData.name);
+  }
+  if (rectData.rx) {
+    rectElement.attr("rx", rectData.rx);
+  }
+  if (rectData.ry) {
+    rectElement.attr("ry", rectData.ry);
+  }
+  if (rectData.attrs !== undefined) {
+    for (const attrKey in rectData.attrs) {
+      rectElement.attr(attrKey, rectData.attrs[attrKey]);
+    }
+  }
+  if (rectData.class) {
+    rectElement.attr("class", rectData.class);
+  }
+  return rectElement;
+}, "drawRect");
+var drawBackgroundRect = /* @__PURE__ */ __name((element, bounds) => {
+  const rectData = {
+    x: bounds.startx,
+    y: bounds.starty,
+    width: bounds.stopx - bounds.startx,
+    height: bounds.stopy - bounds.starty,
+    fill: bounds.fill,
+    stroke: bounds.stroke,
+    class: "rect"
+  };
+  const rectElement = drawRect(element, rectData);
+  rectElement.lower();
+}, "drawBackgroundRect");
+var drawText = /* @__PURE__ */ __name((element, textData) => {
+  const nText = textData.text.replace(lineBreakRegex, " ");
+  const textElem = element.append("text");
+  textElem.attr("x", textData.x);
+  textElem.attr("y", textData.y);
+  textElem.attr("class", "legend");
+  textElem.style("text-anchor", textData.anchor);
+  if (textData.class) {
+    textElem.attr("class", textData.class);
+  }
+  const tspan = textElem.append("tspan");
+  tspan.attr("x", textData.x + textData.textMargin * 2);
+  tspan.text(nText);
+  return textElem;
+}, "drawText");
+var drawImage = /* @__PURE__ */ __name((elem, x, y, link) => {
+  const imageElement = elem.append("image");
+  imageElement.attr("x", x);
+  imageElement.attr("y", y);
+  const sanitizedLink = import_sanitize_url.sanitizeUrl(link);
+  imageElement.attr("xlink:href", sanitizedLink);
+}, "drawImage");
+var drawEmbeddedImage = /* @__PURE__ */ __name((element, x, y, link) => {
+  const imageElement = element.append("use");
+  imageElement.attr("x", x);
+  imageElement.attr("y", y);
+  const sanitizedLink = import_sanitize_url.sanitizeUrl(link);
+  imageElement.attr("xlink:href", `#${sanitizedLink}`);
+}, "drawEmbeddedImage");
+var getNoteRect = /* @__PURE__ */ __name(() => {
+  const noteRectData = {
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    fill: "#EDF2AE",
+    stroke: "#666",
+    anchor: "start",
+    rx: 0,
+    ry: 0
+  };
+  return noteRectData;
+}, "getNoteRect");
+var getTextObj = /* @__PURE__ */ __name(() => {
+  const testObject = {
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    "text-anchor": "start",
+    style: "#666",
+    textMargin: 0,
+    rx: 0,
+    ry: 0,
+    tspan: true
+  };
+  return testObject;
+}, "getTextObj");
+var createTooltip = /* @__PURE__ */ __name(() => {
+  let tooltipElem = select_default(".mermaidTooltip");
+  if (tooltipElem.empty()) {
+    tooltipElem = select_default("body").append("div").attr("class", "mermaidTooltip").style("opacity", 0).style("position", "absolute").style("text-align", "center").style("max-width", "200px").style("padding", "2px").style("font-size", "12px").style("background", "#ffffde").style("border", "1px solid #333").style("border-radius", "2px").style("pointer-events", "none").style("z-index", "100");
+  }
+  return tooltipElem;
+}, "createTooltip");
+
+export { drawRect, drawBackgroundRect, drawText, drawImage, drawEmbeddedImage, getNoteRect, getTextObj, createTooltip };