@conuti-das/prince-ui-dmn 1.0.1

package/dist/index.js

@@ -0,0 +1,1423 @@
+import DmnModdleFactory from 'dmn-moddle';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { Select, SelectItem, Button, AnalyticalTable, Modal, TextField, SegmentedControl, Segment } from '@conuti-das/prince-ui';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/theme/diagram-theme.ts
+function readToken(name, fallback) {
+  if (typeof window === "undefined" || !document?.documentElement) return fallback;
+  const value = getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+  return value || fallback;
+}
+function isDarkMode(scheme = "auto") {
+  if (scheme === "dark") return true;
+  if (scheme === "light") return false;
+  if (typeof document !== "undefined") {
+    const attr = document.documentElement.getAttribute("data-theme");
+    if (attr === "dark" || attr === "cu") return true;
+    if (attr === "light") return false;
+  }
+  if (typeof window !== "undefined" && window.matchMedia) {
+    return window.matchMedia("(prefers-color-scheme: dark)").matches;
+  }
+  return false;
+}
+function getDiagramColors(scheme = "auto") {
+  const dark = isDarkMode(scheme);
+  return {
+    defaultFillColor: readToken("--prn-bg-elevated", dark ? "#1c1c1e" : "#ffffff"),
+    defaultStrokeColor: readToken("--prn-label", dark ? "#e4e4e6" : "#1d1d1f"),
+    defaultLabelColor: readToken("--prn-label", dark ? "#e4e4e6" : "#1d1d1f"),
+    canvasBackground: readToken("--prn-bg", dark ? "#000000" : "#f5f5f7"),
+    accent: readToken("--prn-accent", "#a0d22b")
+  };
+}
+function onThemeChange(onChange) {
+  if (typeof window === "undefined" || !window.MutationObserver) return () => {
+  };
+  const observer = new MutationObserver((mutations) => {
+    for (const m of mutations) {
+      if (m.type === "attributes" && m.attributeName === "data-theme") {
+        onChange();
+        return;
+      }
+    }
+  });
+  observer.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ["data-theme"]
+  });
+  let media;
+  if (window.matchMedia) {
+    media = window.matchMedia("(prefers-color-scheme: dark)");
+    media.addEventListener?.("change", onChange);
+  }
+  return () => {
+    observer.disconnect();
+    media?.removeEventListener?.("change", onChange);
+  };
+}
+var createModdle = DmnModdleFactory;
+var idCounter = 0;
+function makeId(prefix) {
+  idCounter += 1;
+  return `${prefix}_${Date.now().toString(36)}_${idCounter.toString(36)}`;
+}
+var VALID_HIT_POLICIES = [
+  "UNIQUE",
+  "FIRST",
+  "PRIORITY",
+  "ANY",
+  "COLLECT",
+  "RULE ORDER",
+  "OUTPUT ORDER"
+];
+var VALID_AGGREGATIONS = ["SUM", "MIN", "MAX", "COUNT"];
+function normalizeHitPolicy(value) {
+  const v = typeof value === "string" ? value.toUpperCase() : "";
+  return VALID_HIT_POLICIES.includes(v) ? v : "UNIQUE";
+}
+function normalizeAggregation(value) {
+  const v = typeof value === "string" ? value.toUpperCase() : "";
+  return VALID_AGGREGATIONS.includes(v) ? v : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getText(el) {
+  if (!el) return "";
+  const t = el.text;
+  return typeof t === "string" ? t.trim() : "";
+}
+function findDecisions(definitions) {
+  return asArray(definitions.drgElement).filter(
+    (e) => e.$type === "dmn:Decision"
+  );
+}
+function getDecisionTable(decision) {
+  const logic = decision.decisionLogic;
+  return logic && logic.$type === "dmn:DecisionTable" ? logic : void 0;
+}
+function tableToModel(decision, table) {
+  const inputs = asArray(table.input);
+  const outputs = asArray(table.output);
+  asArray(table.annotation);
+  const rules = asArray(table.rule);
+  const inputCols = inputs.map((input) => {
+    const expr = input.inputExpression;
+    const valuesEl = input.inputValues;
+    const inputValues = parseUnaryTestValues(getText(valuesEl));
+    return {
+      id: input.id ?? makeId("input"),
+      label: input.label ?? "",
+      expression: getText(expr),
+      kind: "input",
+      typeRef: expr?.typeRef ?? "string",
+      ...inputValues.length > 0 ? { inputValues } : {}
+    };
+  });
+  const outputCols = outputs.map((output) => {
+    const valuesEl = output.outputValues;
+    const outputValues = parseUnaryTestValues(getText(valuesEl));
+    return {
+      id: output.id ?? makeId("output"),
+      label: output.name ?? output.label ?? "",
+      expression: output.name ?? "",
+      kind: "output",
+      typeRef: output.typeRef ?? "string",
+      ...outputValues.length > 0 ? { inputValues: outputValues } : {}
+    };
+  });
+  const columns = [...inputCols, ...outputCols];
+  const rows = rules.map((rule) => {
+    const inputEntries = asArray(rule.inputEntry);
+    const outputEntries = asArray(rule.outputEntry);
+    const annotationEntries = asArray(rule.annotationEntry);
+    const cells = {};
+    inputEntries.forEach((entry, i) => {
+      const col = inputCols[i];
+      if (col) cells[col.id] = getText(entry);
+    });
+    outputEntries.forEach((entry, i) => {
+      const col = outputCols[i];
+      if (col) cells[col.id] = getText(entry);
+    });
+    const annotation = getText(annotationEntries[0]) || (typeof rule.description === "string" ? rule.description.trim() : "");
+    return {
+      id: rule.id ?? makeId("rule"),
+      cells,
+      ...annotation ? { annotation } : {}
+    };
+  });
+  return {
+    id: decision.id ?? table.id ?? makeId("decision"),
+    name: decision.name ?? "",
+    hitPolicy: normalizeHitPolicy(table.hitPolicy),
+    ...normalizeAggregation(table.aggregation) ? { aggregation: normalizeAggregation(table.aggregation) } : {},
+    columns,
+    rows
+  };
+}
+function parseUnaryTestValues(text) {
+  if (!text) return [];
+  return Array.from(text.matchAll(/"([^"]*)"/g), (m) => m[1] ?? "");
+}
+async function listDecisions(xml) {
+  const { rootElement } = await createModdle().fromXML(xml);
+  return findDecisions(rootElement).filter((d) => getDecisionTable(d)).map((d) => ({ id: d.id ?? "", name: d.name ?? "" }));
+}
+async function parseDmnModel(xml, options = {}) {
+  let result;
+  try {
+    result = await createModdle().fromXML(xml);
+  } catch (e) {
+    throw new Error(`DMN-Parsing fehlgeschlagen: ${e.message}`);
+  }
+  const decisions = findDecisions(result.rootElement);
+  if (decisions.length === 0) {
+    throw new Error("Keine dmn:Decision im Dokument gefunden");
+  }
+  let decision;
+  if (options.decisionId) {
+    decision = decisions.find((d) => d.id === options.decisionId);
+  } else if (typeof options.decisionIndex === "number") {
+    decision = decisions[options.decisionIndex];
+  }
+  if (!decision) {
+    decision = decisions.find((d) => getDecisionTable(d)) ?? decisions[0];
+  }
+  if (!decision) {
+    throw new Error("Decision nicht gefunden");
+  }
+  const table = getDecisionTable(decision);
+  if (!table) {
+    throw new Error(
+      `Decision "${decision.id ?? ""}" enth\xE4lt keine dmn:DecisionTable`
+    );
+  }
+  return tableToModel(decision, table);
+}
+function buildUnaryTests(moddle, text) {
+  return moddle.create("dmn:UnaryTests", { text });
+}
+function buildLiteralExpression(moddle, text, id) {
+  return moddle.create("dmn:LiteralExpression", { id, text });
+}
+function applyModelToTable(moddle, decision, table, model) {
+  const inputCols = model.columns.filter((c) => c.kind === "input");
+  const outputCols = model.columns.filter((c) => c.kind === "output");
+  decision.name = model.name;
+  table.hitPolicy = model.hitPolicy;
+  if (model.hitPolicy === "COLLECT" && model.aggregation) {
+    table.aggregation = model.aggregation;
+  } else {
+    delete table.aggregation;
+  }
+  table.input = inputCols.map((col) => {
+    const inputExpression = buildLiteralExpression(
+      moddle,
+      col.expression,
+      `${col.id}_expr`
+    );
+    inputExpression.typeRef = col.typeRef;
+    const input = moddle.create("dmn:InputClause", {
+      id: col.id,
+      label: col.label,
+      inputExpression
+    });
+    if (col.inputValues && col.inputValues.length > 0) {
+      input.inputValues = buildUnaryTests(
+        moddle,
+        col.inputValues.map((v) => `"${v}"`).join(",")
+      );
+    }
+    return input;
+  });
+  table.output = outputCols.map((col) => {
+    const output = moddle.create("dmn:OutputClause", {
+      id: col.id,
+      name: col.expression || col.label,
+      typeRef: col.typeRef
+    });
+    if (col.label && col.label !== col.expression) {
+      output.label = col.label;
+    }
+    if (col.inputValues && col.inputValues.length > 0) {
+      output.outputValues = buildUnaryTests(
+        moddle,
+        col.inputValues.map((v) => `"${v}"`).join(",")
+      );
+    }
+    return output;
+  });
+  const hasAnnotations = model.rows.some((r) => (r.annotation ?? "").length > 0);
+  table.annotation = hasAnnotations ? [moddle.create("dmn:RuleAnnotationClause", { name: "Annotation" })] : [];
+  table.rule = model.rows.map((row) => {
+    const inputEntry = inputCols.map(
+      (col) => buildUnaryTests(moddle, row.cells[col.id] ?? "")
+    );
+    const outputEntry = outputCols.map(
+      (col, i) => buildLiteralExpression(
+        moddle,
+        row.cells[col.id] ?? "",
+        `${row.id}_out_${i}`
+      )
+    );
+    const rule = moddle.create("dmn:DecisionRule", {
+      id: row.id,
+      inputEntry,
+      outputEntry
+    });
+    if (hasAnnotations) {
+      rule.annotationEntry = [
+        moddle.create("dmn:RuleAnnotation", { text: row.annotation ?? "" })
+      ];
+    }
+    return rule;
+  });
+}
+async function serializeDmnModel(model, originalXml) {
+  const moddle = createModdle();
+  if (originalXml) {
+    const { rootElement } = await moddle.fromXML(originalXml);
+    const decisions = findDecisions(rootElement);
+    const decision2 = decisions.find((d) => d.id === model.id) ?? decisions.find((d) => getDecisionTable(d)) ?? decisions[0];
+    if (!decision2) {
+      throw new Error("Keine Decision zum Schreiben gefunden");
+    }
+    let table2 = getDecisionTable(decision2);
+    if (!table2) {
+      table2 = moddle.create("dmn:DecisionTable", { id: `${decision2.id}_table` });
+      decision2.decisionLogic = table2;
+    }
+    applyModelToTable(moddle, decision2, table2, model);
+    const { xml: xml2 } = await moddle.toXML(rootElement, { format: true });
+    return xml2;
+  }
+  const table = moddle.create("dmn:DecisionTable", {
+    id: `${model.id}_table`
+  });
+  const decision = moddle.create("dmn:Decision", {
+    id: model.id,
+    name: model.name,
+    decisionLogic: table
+  });
+  applyModelToTable(moddle, decision, table, model);
+  const definitions = moddle.create("dmn:Definitions", {
+    id: `Definitions_${model.id}`,
+    name: model.name,
+    namespace: "http://camunda.org/schema/1.0/dmn",
+    drgElement: [decision]
+  });
+  const { xml } = await moddle.toXML(definitions, { format: true });
+  return xml;
+}
+function emptyRow(model) {
+  const cells = {};
+  for (const col of model.columns) cells[col.id] = "";
+  return { id: makeId("rule"), cells };
+}
+function addRow(model, at) {
+  const row = emptyRow(model);
+  const rows = [...model.rows];
+  rows.splice(at ?? rows.length, 0, row);
+  return { ...model, rows };
+}
+function deleteRow(model, rowId) {
+  return { ...model, rows: model.rows.filter((r) => r.id !== rowId) };
+}
+function moveRow(model, rowId, direction) {
+  const idx = model.rows.findIndex((r) => r.id === rowId);
+  if (idx < 0) return model;
+  const target = idx + direction;
+  if (target < 0 || target >= model.rows.length) return model;
+  const rows = [...model.rows];
+  const [moved] = rows.splice(idx, 1);
+  rows.splice(target, 0, moved);
+  return { ...model, rows };
+}
+function updateCell(model, rowId, colId, value) {
+  return {
+    ...model,
+    rows: model.rows.map(
+      (r) => r.id === rowId ? { ...r, cells: { ...r.cells, [colId]: value } } : r
+    )
+  };
+}
+function updateAnnotation(model, rowId, annotation) {
+  return {
+    ...model,
+    rows: model.rows.map(
+      (r) => r.id === rowId ? { ...r, annotation } : r
+    )
+  };
+}
+function setHitPolicy(model, hitPolicy, aggregation) {
+  return {
+    ...model,
+    hitPolicy,
+    ...hitPolicy === "COLLECT" && aggregation ? { aggregation } : { aggregation: void 0 }
+  };
+}
+function addColumn(model, kind, partial) {
+  const id = makeId(kind);
+  const col = {
+    id,
+    label: partial?.label ?? (kind === "input" ? "Neuer Input" : "Neuer Output"),
+    expression: partial?.expression ?? "",
+    kind,
+    typeRef: partial?.typeRef ?? "string",
+    ...partial?.inputValues ? { inputValues: partial.inputValues } : {}
+  };
+  const columns = [...model.columns];
+  if (kind === "input") {
+    const lastInput = columns.map((c) => c.kind).lastIndexOf("input");
+    columns.splice(lastInput + 1, 0, col);
+  } else {
+    columns.push(col);
+  }
+  const rows = model.rows.map((r) => ({
+    ...r,
+    cells: { ...r.cells, [id]: "" }
+  }));
+  return { ...model, columns, rows };
+}
+function updateColumn(model, colId, patch) {
+  return {
+    ...model,
+    columns: model.columns.map(
+      (c) => c.id === colId ? { ...c, ...patch } : c
+    )
+  };
+}
+function deleteColumn(model, colId) {
+  const columns = model.columns.filter((c) => c.id !== colId);
+  const rows = model.rows.map((r) => {
+    const { [colId]: _removed, ...cells } = r.cells;
+    return { ...r, cells };
+  });
+  return { ...model, columns, rows };
+}
+
+// src/model/feel-linter.ts
+var EMPTY_RE = /^(-|)$/;
+var STRING_RE = /^"[^"]*"$/;
+var STRING_LIST_RE = /^"[^"]*"(\s*,\s*"[^"]*")+$/;
+var NUMBER_RE = /^-?\d+(\.\d+)?$/;
+var NUMBER_RANGE_RE = /^[([]\s*-?\d+(\.\d+)?\s*\.\.\s*-?\d+(\.\d+)?\s*[)\]]$/;
+var COMPARISON_RE = /^(>=|<=|>|<)\s*-?\d+(\.\d+)?$/;
+var BOOLEAN_RE = /^(true|false)$/i;
+var NOT_RE = /^not\s*\(.+\)$/;
+var CONTAINS_RE = /^contains\s*\(.+\)$/;
+var FUNCTION_RE = /^[a-zA-Z_][a-zA-Z0-9_]*\s*\(.*\)$/;
+function parseInputValues(inputValues) {
+  const matches = inputValues.matchAll(/"([^"]*)"/g);
+  return Array.from(matches, (m) => m[1] ?? "");
+}
+function lintFeel(expr, column) {
+  const trimmed = expr.trim();
+  const allowed = column?.inputValues && column.inputValues.length > 0 ? column.inputValues.flatMap(parseInputValues) : [];
+  if (EMPTY_RE.test(trimmed)) {
+    return { valid: true, type: "any" };
+  }
+  if (STRING_LIST_RE.test(trimmed)) {
+    if (allowed.length > 0) {
+      const vals = trimmed.split(",").map((v) => v.trim().replace(/^"|"$/g, ""));
+      const invalid = vals.filter((v) => !allowed.includes(v));
+      if (invalid.length > 0) {
+        return {
+          valid: false,
+          message: `Nicht erlaubt: ${invalid.join(", ")}`,
+          type: "string list"
+        };
+      }
+    }
+    return { valid: true, type: "string list" };
+  }
+  if (STRING_RE.test(trimmed)) {
+    if (allowed.length > 0) {
+      const val = trimmed.replace(/^"|"$/g, "");
+      if (!allowed.includes(val)) {
+        return {
+          valid: false,
+          message: `"${val}" ist nicht in den erlaubten Werten`,
+          type: "string"
+        };
+      }
+    }
+    return { valid: true, type: "string" };
+  }
+  if (NUMBER_RANGE_RE.test(trimmed)) {
+    return { valid: true, type: "number range" };
+  }
+  if (COMPARISON_RE.test(trimmed)) {
+    return { valid: true, type: "number range" };
+  }
+  if (NUMBER_RE.test(trimmed)) {
+    return { valid: true, type: "number" };
+  }
+  if (BOOLEAN_RE.test(trimmed)) {
+    return { valid: true, type: "boolean" };
+  }
+  if (NOT_RE.test(trimmed) || CONTAINS_RE.test(trimmed) || FUNCTION_RE.test(trimmed)) {
+    return { valid: true, type: "expression" };
+  }
+  return { valid: false, message: `Unbekannter FEEL-Ausdruck: "${trimmed}"` };
+}
+var HIT_POLICIES = [
+  "UNIQUE",
+  "FIRST",
+  "PRIORITY",
+  "ANY",
+  "COLLECT",
+  "RULE ORDER",
+  "OUTPUT ORDER"
+];
+var AGGREGATIONS = ["SUM", "MIN", "MAX", "COUNT"];
+var TYPE_REFS = ["string", "number", "boolean", "date"];
+var FEEL_SNIPPETS = [
+  'not("X")',
+  "[1..100]",
+  ">= 0",
+  '"Ja","Nein"',
+  'date("2026-01-01")'
+];
+function DmnTableEditor({
+  value,
+  defaultValue,
+  onChange,
+  onSave,
+  decisionId,
+  title,
+  subtitle,
+  onSwitchToExpert,
+  cellPlugins = [],
+  actionsSlot,
+  readOnly = false,
+  className
+}) {
+  const isControlled = value !== void 0;
+  const sourceXml = isControlled ? value : defaultValue;
+  const [model, setModel] = useState(null);
+  const [error, setError] = useState(null);
+  const [saving, setSaving] = useState(false);
+  const [selectedRowId, setSelectedRowId] = useState(null);
+  const [editing, setEditing] = useState(null);
+  const [feel, setFeel] = useState(null);
+  const [columnDialog, setColumnDialog] = useState(null);
+  const [addColumnDialog, setAddColumnDialog] = useState(
+    null
+  );
+  const originalXmlRef = useRef(sourceXml);
+  useEffect(() => {
+    let cancelled = false;
+    if (!sourceXml) {
+      setModel(null);
+      setError(null);
+      return;
+    }
+    originalXmlRef.current = sourceXml;
+    parseDmnModel(sourceXml, decisionId ? { decisionId } : {}).then((m) => {
+      if (!cancelled) {
+        setModel(m);
+        setError(null);
+      }
+    }).catch((e) => {
+      if (!cancelled) {
+        setError(e.message);
+        setModel(null);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [sourceXml, decisionId]);
+  const commitModel = useCallback(
+    (next) => {
+      setModel(next);
+      if (onChange) {
+        void serializeDmnModel(next, originalXmlRef.current).then((xml) => {
+          originalXmlRef.current = xml;
+          onChange(xml);
+        });
+      }
+    },
+    [onChange]
+  );
+  const lintMap = useMemo(() => {
+    const map = {};
+    if (!model) return map;
+    for (const row of model.rows) {
+      for (const col of model.columns) {
+        map[`${row.id}:${col.id}`] = lintFeel(row.cells[col.id] ?? "", col);
+      }
+    }
+    return map;
+  }, [model]);
+  const errorCount = useMemo(
+    () => Object.values(lintMap).filter((r) => !r.valid).length,
+    [lintMap]
+  );
+  const handleSave = useCallback(async () => {
+    if (!model || !onSave || readOnly) return;
+    setSaving(true);
+    try {
+      const xml = await serializeDmnModel(model, originalXmlRef.current);
+      originalXmlRef.current = xml;
+      await onSave(xml);
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setSaving(false);
+    }
+  }, [model, onSave, readOnly]);
+  useEffect(() => {
+    const handler = (e) => {
+      if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "s") {
+        e.preventDefault();
+        void handleSave();
+      }
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [handleSave]);
+  const setCell = useCallback(
+    (rowId, colId, val) => {
+      if (!model) return;
+      commitModel(updateCell(model, rowId, colId, val));
+    },
+    [model, commitModel]
+  );
+  const findPlugin = useCallback(
+    (col) => cellPlugins.find((p) => p.matches(col)),
+    [cellPlugins]
+  );
+  const columns = useMemo(() => {
+    if (!model) return [];
+    const idxCol = {
+      id: "__index",
+      header: "#",
+      width: "44px",
+      align: "end",
+      sortable: false,
+      cellRender: ({ index }) => /* @__PURE__ */ jsx("span", { className: "prn-dmn-index", children: index + 1 })
+    };
+    const dataCols = model.columns.map((col) => ({
+      id: col.id,
+      sortable: false,
+      header: /* @__PURE__ */ jsx(
+        ColumnHeader,
+        {
+          column: col,
+          readOnly,
+          onEdit: () => setColumnDialog(col.id),
+          onRename: (label) => commitModel(updateColumn(model, col.id, { label }))
+        }
+      ),
+      cellRender: ({ row }) => {
+        const cellVal = row.cells[col.id] ?? "";
+        const lint = lintMap[`${row.id}:${col.id}`];
+        const isEditing = editing?.rowId === row.id && editing?.colId === col.id;
+        const plugin = findPlugin(col);
+        if (isEditing && !readOnly) {
+          if (plugin) {
+            return plugin.renderEditor({
+              value: cellVal,
+              onChange: (next) => setCell(row.id, col.id, next),
+              onCommit: () => setEditing(null),
+              onCancel: () => setEditing(null),
+              column: col
+            });
+          }
+          return /* @__PURE__ */ jsx(
+            InlineInput,
+            {
+              value: cellVal,
+              onCommit: (v) => {
+                setCell(row.id, col.id, v);
+                setEditing(null);
+              },
+              onCancel: () => setEditing(null)
+            }
+          );
+        }
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "prn-dmn-cell",
+            "data-invalid": lint && !lint.valid ? "true" : void 0,
+            title: lint && !lint.valid ? lint.message : void 0,
+            onClick: () => {
+              if (!readOnly) setEditing({ rowId: row.id, colId: col.id });
+            },
+            onDoubleClick: () => {
+              if (!readOnly)
+                setFeel({
+                  rowId: row.id,
+                  colId: col.id,
+                  column: col,
+                  value: cellVal
+                });
+            },
+            children: [
+              cellVal ? /* @__PURE__ */ jsx("span", { children: cellVal }) : /* @__PURE__ */ jsx("span", { className: "prn-dmn-cell__empty", children: "\u2013" }),
+              lint && !lint.valid && /* @__PURE__ */ jsx("span", { className: "prn-dmn-cell__warn", children: "\u26A0" })
+            ]
+          }
+        );
+      }
+    }));
+    const annotationCol = {
+      id: "__annotation",
+      header: "Annotation",
+      sortable: false,
+      minWidth: 140,
+      cellRender: ({ row }) => {
+        const isEditing = editing?.rowId === row.id && editing?.colId === "__annotation";
+        if (isEditing && !readOnly) {
+          return /* @__PURE__ */ jsx(
+            InlineInput,
+            {
+              value: row.annotation ?? "",
+              onCommit: (v) => {
+                if (model) commitModel(updateAnnotation(model, row.id, v));
+                setEditing(null);
+              },
+              onCancel: () => setEditing(null)
+            }
+          );
+        }
+        return /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: "prn-dmn-cell",
+            onClick: () => {
+              if (!readOnly)
+                setEditing({ rowId: row.id, colId: "__annotation" });
+            },
+            children: row.annotation ? /* @__PURE__ */ jsx("span", { children: row.annotation }) : /* @__PURE__ */ jsx("span", { className: "prn-dmn-cell__empty", children: "\u2013" })
+          }
+        );
+      }
+    };
+    return [idxCol, ...dataCols, annotationCol];
+  }, [model, lintMap, editing, readOnly, findPlugin, setCell, commitModel]);
+  const rowsView = useMemo(
+    () => model ? model.rows.map((row, index) => ({ row, index })) : [],
+    [model]
+  );
+  if (error) {
+    return /* @__PURE__ */ jsx("div", { className: cls("prn-dmn-table", className), children: /* @__PURE__ */ jsxs("div", { className: "prn-dmn-lint", "data-tone": "negative", children: [
+      "Fehler: ",
+      error
+    ] }) });
+  }
+  if (!model) {
+    return /* @__PURE__ */ jsx("div", { className: cls("prn-dmn-table", className), children: /* @__PURE__ */ jsx("div", { className: "prn-dmn-lint", children: "Kein DMN-Dokument geladen." }) });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: cls("prn-dmn-table", className), "data-prn-dmn-table": true, children: [
+    /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar", children: [
+      /* @__PURE__ */ jsxs("div", { className: "prn-dmn-title", children: [
+        title && /* @__PURE__ */ jsx("span", { className: "prn-dmn-title__name", children: title }),
+        subtitle && /* @__PURE__ */ jsx("span", { className: "prn-dmn-title__meta", children: subtitle }),
+        !title && /* @__PURE__ */ jsx(
+          InlineEditableText,
+          {
+            className: "prn-dmn-title__name",
+            value: model.name || model.id,
+            readOnly,
+            ariaLabel: "Decision-Name bearbeiten",
+            onCommit: (v) => commitModel({ ...model, name: v })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar-group", children: [
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            "aria-label": "Hit-Policy",
+            selectedKey: model.hitPolicy,
+            isDisabled: readOnly,
+            onSelectionChange: (key) => commitModel(
+              setHitPolicy(model, key, model.aggregation)
+            ),
+            children: HIT_POLICIES.map((p) => /* @__PURE__ */ jsx(SelectItem, { id: p, textValue: p, children: p }, p))
+          }
+        ),
+        model.hitPolicy === "COLLECT" && /* @__PURE__ */ jsx(
+          Select,
+          {
+            "aria-label": "Aggregation",
+            selectedKey: model.aggregation ?? "SUM",
+            isDisabled: readOnly,
+            onSelectionChange: (key) => commitModel(
+              setHitPolicy(model, "COLLECT", key)
+            ),
+            children: AGGREGATIONS.map((a) => /* @__PURE__ */ jsx(SelectItem, { id: a, textValue: a, children: a }, a))
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("span", { className: "prn-dmn-spacer" }),
+      /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar-group", children: [
+        actionsSlot,
+        onSwitchToExpert && /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: onSwitchToExpert, children: "Experte" }),
+        onSave && /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "filled",
+            isDisabled: saving || readOnly,
+            onPress: () => void handleSave(),
+            children: saving ? "Speichern\u2026" : "Speichern"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "prn-dmn-lint",
+        "data-tone": errorCount === 0 ? "positive" : "negative",
+        role: "status",
+        children: errorCount === 0 ? `\u2713 Alle ${model.rows.length} Regeln valide` : `\u26A0 ${errorCount} ung\xFCltige Zelle(n)`
+      }
+    ),
+    !readOnly && /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar prn-dmn-toolbar--sub", children: [
+      /* @__PURE__ */ jsxs("span", { className: "prn-dmn-title__meta", children: [
+        "Regeln (",
+        model.rows.length,
+        ")"
+      ] }),
+      /* @__PURE__ */ jsx("span", { className: "prn-dmn-spacer" }),
+      /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar-group", children: [
+        /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: () => setAddColumnDialog("input"), children: "+ Input" }),
+        /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: () => setAddColumnDialog("output"), children: "+ Output" }),
+        /* @__PURE__ */ jsx(Button, { variant: "tinted", onPress: () => commitModel(addRow(model)), children: "+ Zeile" }),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "plain",
+            isDisabled: !selectedRowId,
+            onPress: () => {
+              if (selectedRowId) {
+                commitModel(moveRow(model, selectedRowId, -1));
+              }
+            },
+            children: "\u2191"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "plain",
+            isDisabled: !selectedRowId,
+            onPress: () => {
+              if (selectedRowId) {
+                commitModel(moveRow(model, selectedRowId, 1));
+              }
+            },
+            children: "\u2193"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "plain",
+            isDisabled: !selectedRowId,
+            onPress: () => {
+              if (selectedRowId) {
+                commitModel(deleteRow(model, selectedRowId));
+                setSelectedRowId(null);
+              }
+            },
+            children: "Zeile l\xF6schen"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "prn-dmn-table__body", children: /* @__PURE__ */ jsx(
+      AnalyticalTable,
+      {
+        data: rowsView,
+        columns,
+        getRowId: (r) => r.row.id,
+        selectionMode: readOnly ? "none" : "single",
+        selectionBehavior: "rowSelector",
+        selectedKeys: new Set(selectedRowId ? [selectedRowId] : []),
+        onSelectionChange: (keys) => {
+          const arr = Array.from(keys);
+          setSelectedRowId(arr[0] ?? null);
+        }
+      }
+    ) }),
+    feel && /* @__PURE__ */ jsx(
+      Modal,
+      {
+        isOpen: true,
+        title: `FEEL \u2014 ${feel.column.label || feel.column.expression}`,
+        onOpenChange: (open) => {
+          if (!open) setFeel(null);
+        },
+        children: /* @__PURE__ */ jsx(
+          FeelEditor,
+          {
+            initial: feel.value,
+            column: feel.column,
+            onCancel: () => setFeel(null),
+            onApply: (v) => {
+              setCell(feel.rowId, feel.colId, v);
+              setFeel(null);
+            }
+          }
+        )
+      }
+    ),
+    columnDialog && /* @__PURE__ */ jsx(
+      ColumnDialog,
+      {
+        column: model.columns.find((c) => c.id === columnDialog),
+        onClose: () => setColumnDialog(null),
+        onApply: (patch) => {
+          commitModel(updateColumn(model, columnDialog, patch));
+          setColumnDialog(null);
+        },
+        onDelete: () => {
+          commitModel(deleteColumn(model, columnDialog));
+          setColumnDialog(null);
+        }
+      }
+    ),
+    addColumnDialog && /* @__PURE__ */ jsx(
+      ColumnDialog,
+      {
+        kind: addColumnDialog,
+        onClose: () => setAddColumnDialog(null),
+        onApply: (patch) => {
+          commitModel(addColumn(model, addColumnDialog, patch));
+          setAddColumnDialog(null);
+        }
+      }
+    )
+  ] });
+}
+function ColumnHeader({
+  column,
+  readOnly,
+  onEdit,
+  onRename
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "prn-dmn-colhead", "data-kind": column.kind, children: [
+    /* @__PURE__ */ jsxs("div", { className: "prn-dmn-colhead__top", children: [
+      /* @__PURE__ */ jsxs("span", { className: "prn-dmn-colhead__kind", children: [
+        column.kind === "input" ? "Input" : "Output",
+        " \xB7 ",
+        column.typeRef
+      ] }),
+      !readOnly && /* @__PURE__ */ jsx(
+        Button,
+        {
+          className: "prn-dmn-colhead__edit",
+          variant: "plain",
+          onPress: onEdit,
+          "aria-label": "Spalte bearbeiten",
+          children: "\u2699"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      InlineEditableText,
+      {
+        className: "prn-dmn-colhead__label",
+        value: column.label || column.expression,
+        readOnly,
+        ariaLabel: "Spaltentitel bearbeiten",
+        onCommit: onRename
+      }
+    ),
+    column.label && column.expression && column.label !== column.expression && /* @__PURE__ */ jsx("span", { className: "prn-dmn-colhead__expr", children: column.expression })
+  ] });
+}
+function InlineInput({
+  value,
+  onCommit,
+  onCancel
+}) {
+  const [v, setV] = useState(value);
+  const ref = useRef(null);
+  const committed = useRef(false);
+  useEffect(() => {
+    ref.current?.focus();
+    ref.current?.select();
+  }, []);
+  const commit = () => {
+    if (committed.current) return;
+    committed.current = true;
+    onCommit(v);
+  };
+  return /* @__PURE__ */ jsx(
+    "input",
+    {
+      ref,
+      className: "prn-dmn-cell__input",
+      value: v,
+      onChange: (e) => setV(e.target.value),
+      onBlur: commit,
+      onClick: (e) => e.stopPropagation(),
+      onKeyDown: (e) => {
+        if (e.key === "Enter" || e.key === "Tab") {
+          e.preventDefault();
+          commit();
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          committed.current = true;
+          onCancel();
+        }
+      }
+    }
+  );
+}
+function FeelEditor({
+  initial,
+  column,
+  onApply,
+  onCancel
+}) {
+  const [text, setText] = useState(initial);
+  const lint = lintFeel(text, column);
+  return /* @__PURE__ */ jsxs("div", { className: "prn-dmn-feel", children: [
+    /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        autoFocus: true,
+        className: "prn-dmn-feel__editor",
+        "data-valid": lint.valid ? "true" : "false",
+        value: text,
+        onChange: (e) => setText(e.target.value),
+        onKeyDown: (e) => {
+          if (e.key === "Enter" && (e.metaKey || e.ctrlKey) && lint.valid) {
+            onApply(text);
+          }
+          if (e.key === "Escape") onCancel();
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "prn-dmn-feel__status", "data-valid": lint.valid ? "true" : "false", children: [
+      /* @__PURE__ */ jsx("span", { children: lint.valid ? "\u2713 Valide" : "\u2717 Ung\xFCltig" }),
+      lint.message && /* @__PURE__ */ jsx("span", { children: lint.message }),
+      lint.type && /* @__PURE__ */ jsx("span", { className: "prn-dmn-feel__type", children: lint.type })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "prn-dmn-feel__snippets", children: FEEL_SNIPPETS.map((s) => /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: () => setText(s), children: s }, s)) }),
+    column.inputValues && column.inputValues.length > 0 && /* @__PURE__ */ jsxs("div", { className: "prn-dmn-feel__hint", children: [
+      "Erlaubte Werte:",
+      " ",
+      /* @__PURE__ */ jsx("code", { children: column.inputValues.map((v) => `"${v}"`).join(", ") })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "prn-dmn-feel__footer", children: [
+      /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: onCancel, children: "Abbrechen" }),
+      /* @__PURE__ */ jsx(Button, { variant: "filled", isDisabled: !lint.valid, onPress: () => onApply(text), children: "\xDCbernehmen" })
+    ] })
+  ] });
+}
+function ColumnDialog({
+  column,
+  kind,
+  onApply,
+  onDelete,
+  onClose
+}) {
+  const [label, setLabel] = useState(column?.label ?? "");
+  const [expression, setExpression] = useState(column?.expression ?? "");
+  const [typeRef, setTypeRef] = useState(column?.typeRef ?? "string");
+  const [inputValues, setInputValues] = useState(
+    (column?.inputValues ?? []).join(", ")
+  );
+  const effectiveKind = column?.kind ?? kind ?? "input";
+  return /* @__PURE__ */ jsx(
+    Modal,
+    {
+      isOpen: true,
+      title: column ? "Spalte bearbeiten" : `Neue ${effectiveKind === "input" ? "Input" : "Output"}-Spalte`,
+      onOpenChange: (open) => {
+        if (!open) onClose();
+      },
+      children: /* @__PURE__ */ jsxs("div", { className: "prn-dmn-feel prn-dmn-feel--dialog", children: [
+        /* @__PURE__ */ jsx(TextField, { label: "Label", value: label, onChange: setLabel }),
+        /* @__PURE__ */ jsx(
+          TextField,
+          {
+            label: effectiveKind === "input" ? "FEEL-Expression" : "Output-Name",
+            value: expression,
+            onChange: setExpression
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            label: "Typ",
+            selectedKey: typeRef,
+            onSelectionChange: (k) => setTypeRef(String(k)),
+            children: TYPE_REFS.map((t) => /* @__PURE__ */ jsx(SelectItem, { id: t, textValue: t, children: t }, t))
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          TextField,
+          {
+            label: "Erlaubte Werte (kommagetrennt)",
+            value: inputValues,
+            onChange: setInputValues,
+            description: "z. B. Ja, Nein"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "prn-dmn-feel__footer", children: [
+          onDelete && /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: onDelete, children: "L\xF6schen" }),
+          /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: onClose, children: "Abbrechen" }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "filled",
+              onPress: () => onApply({
+                label,
+                expression,
+                typeRef,
+                inputValues: inputValues.split(",").map((v) => v.trim()).filter(Boolean)
+              }),
+              children: column ? "Speichern" : "Anlegen"
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+}
+function InlineEditableText({
+  value,
+  onCommit,
+  readOnly,
+  className,
+  ariaLabel
+}) {
+  const [editing, setEditing] = useState(false);
+  const [draft, setDraft] = useState(value);
+  const ref = useRef(null);
+  useEffect(() => {
+    if (editing) {
+      ref.current?.focus();
+      ref.current?.select();
+    }
+  }, [editing]);
+  if (readOnly) return /* @__PURE__ */ jsx("span", { className, children: value });
+  if (editing) {
+    return /* @__PURE__ */ jsx(
+      "input",
+      {
+        ref,
+        className: cls(className, "prn-dmn-inline-edit"),
+        value: draft,
+        "aria-label": ariaLabel,
+        onChange: (e) => setDraft(e.target.value),
+        onClick: (e) => e.stopPropagation(),
+        onBlur: () => {
+          setEditing(false);
+          if (draft !== value) onCommit(draft);
+        },
+        onKeyDown: (e) => {
+          if (e.key === "Enter") {
+            e.preventDefault();
+            e.target.blur();
+          } else if (e.key === "Escape") {
+            e.preventDefault();
+            setDraft(value);
+            setEditing(false);
+          }
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      className: cls(className, "prn-dmn-inline-trigger"),
+      title: "Zum Bearbeiten klicken",
+      onClick: (e) => {
+        e.stopPropagation();
+        setDraft(value);
+        setEditing(true);
+      },
+      children: value
+    }
+  );
+}
+function cls(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function DmnExpertEditor({
+  value,
+  defaultValue,
+  onChange,
+  onSave,
+  colorScheme = "auto",
+  actionsSlot,
+  onSwitchToTable,
+  propertiesPanel = true,
+  className
+}) {
+  const canvasRef = useRef(null);
+  const panelRef = useRef(null);
+  const modelerRef = useRef(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [saving, setSaving] = useState(false);
+  const [hasPanel, setHasPanel] = useState(false);
+  const [themeTick, setThemeTick] = useState(0);
+  const xml = value ?? defaultValue ?? "";
+  useEffect(() => onThemeChange(() => setThemeTick((t) => t + 1)), []);
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+    const boot = async () => {
+      const container = canvasRef.current;
+      if (!container) return;
+      if (modelerRef.current) {
+        try {
+          modelerRef.current.destroy();
+        } catch {
+        }
+        modelerRef.current = null;
+      }
+      try {
+        const mod = await import('dmn-js/lib/Modeler');
+        if (cancelled || !canvasRef.current) return;
+        const colors = getDiagramColors(colorScheme);
+        const rendererColors = {
+          defaultFillColor: colors.defaultFillColor,
+          defaultStrokeColor: colors.defaultStrokeColor,
+          defaultLabelColor: colors.defaultLabelColor
+        };
+        const opts = {
+          container,
+          drd: {
+            drawCustom: false,
+            // dmn-js-DRD injiziert seine Renderer-Config aus `config.drdRenderer`
+            // (DrdRenderer.$inject = ['config.drdRenderer', …]). Der frühere Key
+            // `bpmnRenderer` wurde ignoriert → Shapes blieben hartcodiert weiß/
+            // schwarz. Beide Keys setzen wir zur Sicherheit.
+            drdRenderer: rendererColors,
+            bpmnRenderer: rendererColors
+          }
+        };
+        let panelLoaded = false;
+        if (propertiesPanel && panelRef.current) {
+          const panelMods = await loadPropertiesPanel();
+          if (panelMods && !cancelled) {
+            opts.drd = {
+              ...opts.drd,
+              propertiesPanel: { parent: panelRef.current },
+              additionalModules: panelMods.modules
+            };
+            opts.moddleExtensions = panelMods.moddleExtensions;
+            panelLoaded = true;
+          }
+        }
+        const Modeler = mod.default;
+        const modeler = new Modeler(opts);
+        modelerRef.current = modeler;
+        if (!cancelled) setHasPanel(panelLoaded);
+        if (xml.trim()) {
+          await modeler.importXML(xml);
+        }
+        if (onChange) {
+          modeler.on("views.changed", () => emitChange());
+          modeler.on("commandStack.changed", () => emitChange());
+        }
+      } catch (e) {
+        if (!cancelled) setError(e.message);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    };
+    const emitChange = () => {
+      const m = modelerRef.current;
+      if (!m || !onChange) return;
+      m.saveXML({ format: true }).then(({ xml: out }) => onChange(out)).catch(() => {
+      });
+    };
+    void boot();
+    return () => {
+      cancelled = true;
+    };
+  }, [colorScheme, propertiesPanel, themeTick]);
+  useEffect(() => {
+    return () => {
+      if (modelerRef.current) {
+        try {
+          modelerRef.current.destroy();
+        } catch {
+        }
+        modelerRef.current = null;
+      }
+    };
+  }, []);
+  const handleSave = useCallback(async () => {
+    const m = modelerRef.current;
+    if (!m || !onSave) return;
+    setSaving(true);
+    try {
+      const { xml: out } = await m.saveXML({ format: true });
+      await onSave(out);
+    } catch (e) {
+      setError(e.message);
+    } finally {
+      setSaving(false);
+    }
+  }, [onSave]);
+  return /* @__PURE__ */ jsxs("div", { className: cls2("prn-dmn-expert", className), "data-prn-dmn-expert": true, children: [
+    /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar", children: [
+      /* @__PURE__ */ jsx("span", { className: "prn-dmn-title__name", children: "DMN \u2014 Experten-Modus" }),
+      /* @__PURE__ */ jsx("span", { className: "prn-dmn-spacer" }),
+      /* @__PURE__ */ jsxs("div", { className: "prn-dmn-toolbar-group", children: [
+        actionsSlot,
+        onSwitchToTable && /* @__PURE__ */ jsx(Button, { variant: "plain", onPress: onSwitchToTable, children: "Tabelle" }),
+        onSave && /* @__PURE__ */ jsx(
+          Button,
+          {
+            variant: "filled",
+            isDisabled: saving || loading,
+            onPress: () => void handleSave(),
+            children: saving ? "Speichern\u2026" : "Speichern"
+          }
+        )
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsxs("div", { className: "prn-dmn-lint", "data-tone": "negative", role: "alert", children: [
+      "Fehler: ",
+      error
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "prn-dmn-expert__stage", children: [
+      /* @__PURE__ */ jsx("div", { ref: canvasRef, className: "prn-dmn-expert__canvas" }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref: panelRef,
+          className: "prn-dmn-expert__panel",
+          "data-visible": hasPanel ? "true" : "false"
+        }
+      ),
+      loading && /* @__PURE__ */ jsx("div", { className: "prn-dmn-expert__loading", role: "status", children: "dmn-js wird geladen\u2026" })
+    ] })
+  ] });
+}
+var dynamicImport = (spec) => import(
+  /* @vite-ignore */
+  /* webpackIgnore: true */
+  spec
+);
+async function loadPropertiesPanel() {
+  try {
+    const [panel, provider, moddle] = await Promise.all([
+      dynamicImport("@bpmn-io/properties-panel"),
+      dynamicImport("dmn-js-properties-panel"),
+      dynamicImport("camunda-dmn-moddle/resources/camunda.json").catch(
+        () => null
+      )
+    ]);
+    const pnl = panel;
+    const prov = provider;
+    const modules = [
+      pnl.PropertiesPanelModule ?? panel,
+      prov.DmnPropertiesPanelModule ?? prov.default,
+      prov.CamundaPropertiesProviderModule
+    ].filter(Boolean);
+    return {
+      modules,
+      moddleExtensions: moddle ? { camunda: moddle.default ?? moddle } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function cls2(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+function DmnEditor({
+  value,
+  defaultValue,
+  onChange,
+  onSave,
+  defaultMode = "table",
+  mode: controlledMode,
+  onModeChange,
+  colorScheme,
+  title,
+  subtitle,
+  cellPlugins,
+  actionsSlot,
+  decisionId,
+  className
+}) {
+  const [internalMode, setInternalMode] = useState(defaultMode);
+  const mode = controlledMode ?? internalMode;
+  const [bufferXml, setBufferXml] = useState(
+    value ?? defaultValue
+  );
+  const isControlled = value !== void 0;
+  const currentXml = isControlled ? value : bufferXml;
+  const setMode = (next) => {
+    if (controlledMode === void 0) setInternalMode(next);
+    onModeChange?.(next);
+  };
+  const handleChange = (xml) => {
+    if (!isControlled) setBufferXml(xml);
+    onChange?.(xml);
+  };
+  const switcher = /* @__PURE__ */ jsxs(
+    SegmentedControl,
+    {
+      "aria-label": "Editor-Modus",
+      selectedKeys: /* @__PURE__ */ new Set([mode]),
+      onSelectionChange: (keys) => {
+        const next = Array.from(keys)[0];
+        if (next) setMode(next);
+      },
+      children: [
+        /* @__PURE__ */ jsx(Segment, { id: "table", children: "Tabelle" }),
+        /* @__PURE__ */ jsx(Segment, { id: "expert", children: "Experte" })
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsx("div", { className: cls3("prn-dmn-editor", className), "data-prn-dmn-editor": true, children: mode === "table" ? /* @__PURE__ */ jsx(
+    DmnTableEditor,
+    {
+      value: currentXml,
+      onChange: handleChange,
+      onSave,
+      decisionId,
+      title,
+      subtitle,
+      cellPlugins,
+      actionsSlot: /* @__PURE__ */ jsxs(Fragment, { children: [
+        switcher,
+        actionsSlot
+      ] })
+    }
+  ) : /* @__PURE__ */ jsx(
+    DmnExpertEditor,
+    {
+      value: currentXml,
+      onChange: handleChange,
+      onSave,
+      colorScheme,
+      actionsSlot: /* @__PURE__ */ jsxs(Fragment, { children: [
+        switcher,
+        actionsSlot
+      ] })
+    }
+  ) });
+}
+function cls3(...parts) {
+  return parts.filter(Boolean).join(" ");
+}
+
+export { DmnEditor, DmnExpertEditor, DmnTableEditor, addColumn, addRow, deleteColumn, deleteRow, emptyRow, getDiagramColors, isDarkMode, lintFeel, listDecisions, makeId, moveRow, onThemeChange, parseDmnModel, parseInputValues, readToken, serializeDmnModel, setHitPolicy, updateAnnotation, updateCell, updateColumn };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map