prince-ui-dmn 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,231 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * Datenmodell der DMN-Entscheidungstabelle — geteilter Vertrag zwischen dem
+ * einstiegsfreundlichen Tabelleneditor (⑤) und dem dmn-js-Expertenmodus (⑥),
+ * damit das Umschalten verlustfrei bleibt.
+ *
+ * Anders als der maco-process-studio-Prototyp (lossy XML-Patch) wird dieses
+ * Modell verlustfrei über `dmn-moddle` serialisiert (inkl. Spaltenänderungen).
+ */
+type HitPolicy = "UNIQUE" | "FIRST" | "PRIORITY" | "ANY" | "COLLECT" | "RULE ORDER" | "OUTPUT ORDER";
+/** COLLECT-Aggregation (nur bei hitPolicy === "COLLECT"). */
+type Aggregation = "SUM" | "MIN" | "MAX" | "COUNT";
+type DmnColumnKind = "input" | "output";
+interface DmnColumn {
+    id: string;
+    /** Anzeigename der Spalte (Input: label, Output: name) */
+    label: string;
+    /** FEEL-Input-Expression (Input) bzw. Output-Name */
+    expression: string;
+    kind: DmnColumnKind;
+    /** FEEL-Typ, z. B. string | number | boolean | date */
+    typeRef: string;
+    /** optionale erlaubte Werte (für Validierung/Autocomplete) */
+    inputValues?: string[];
+}
+interface DmnRow {
+    id: string;
+    /** colId -> FEEL-Entry */
+    cells: Record<string, string>;
+    annotation?: string;
+}
+interface DmnTableModel {
+    /** id der Decision */
+    id: string;
+    name: string;
+    hitPolicy: HitPolicy;
+    aggregation?: Aggregation;
+    columns: DmnColumn[];
+    rows: DmnRow[];
+}
+/** Ergebnis einer FEEL-Lint-Prüfung pro Zelle. */
+interface FeelLintResult {
+    valid: boolean;
+    message?: string;
+}
+/** Light/Dark-Steuerung. */
+type DiagramColorScheme = "auto" | "light" | "dark";
+/**
+ * Optionales Zell-Plugin (z. B. Prüfidentifikator-Autocomplete) — hält die
+ * Pakete frei von MaCo-Domänenwissen.
+ */
+interface DmnCellPlugin {
+    /** trifft zu, wenn die Spalte dieses Plugin nutzen soll */
+    matches(column: DmnColumn): boolean;
+    /** liefert das Edit-Control für die Zelle */
+    renderEditor(props: {
+        value: string;
+        onChange(next: string): void;
+        onCommit(): void;
+        onCancel(): void;
+        column: DmnColumn;
+    }): react.ReactNode;
+}
+
+/**
+ * Theme-Bridge für dmn-js (DRD-SVG-Ansicht) — kolokierte Kopie des bpmn-Pakets
+ * (bewusst kein geteiltes 4. Paket). Liest prince-ui-Tokens (`--prn-*`) und
+ * hört auf `data-theme`.
+ */
+
+interface DiagramColors {
+    defaultFillColor: string;
+    defaultStrokeColor: string;
+    defaultLabelColor: string;
+    canvasBackground: string;
+    accent: string;
+}
+declare function readToken(name: string, fallback: string): string;
+declare function isDarkMode(scheme?: DiagramColorScheme): boolean;
+declare function getDiagramColors(scheme?: DiagramColorScheme): DiagramColors;
+declare function onThemeChange(onChange: () => void): () => void;
+
+/**
+ * Verlustfreies Mapping zwischen DMN-XML und dem geteilten `DmnTableModel`
+ * (Spec §7) — über **dmn-moddle**, NICHT über den lossy XML-String-Patch des
+ * maco-process-studio-Prototyps.
+ *
+ * - `parseDmnModel(xml)` liest die (per Index/ID wählbare) Decision-Table.
+ * - `serializeDmnModel(model, originalXml?)` schreibt das Modell zurück und
+ *   bewahrt dabei alle nicht angefassten Teile des Originaldokuments
+ *   (weitere Decisions, DRD/DI, Imports, Annotationen anderer Tabellen).
+ *
+ * dmn-moddle bringt keine eigenen Typdeklarationen mit — die Moddle-Elemente
+ * werden hier über schlanke lokale Interfaces typisiert (siehe `Moddle*`).
+ */
+
+/** Erzeugt eine stabile, gut lesbare ID. Nur für neu angelegte Elemente. */
+declare function makeId(prefix: string): string;
+interface DmnDecisionRef {
+    id: string;
+    name: string;
+}
+interface ParseOptions {
+    /** Wähle die Decision per ID; Default: erste Decision mit Table. */
+    decisionId?: string;
+    /** Alternativ per Index (0-basiert). */
+    decisionIndex?: number;
+}
+/** Liste der editierbaren Decisions im Dokument (für Auswahl-UI). */
+declare function listDecisions(xml: string): Promise<DmnDecisionRef[]>;
+/**
+ * Parst DMN-XML zu einem `DmnTableModel`. Wirft, wenn keine Decision-Table
+ * gefunden wird oder das XML ungültig ist.
+ */
+declare function parseDmnModel(xml: string, options?: ParseOptions): Promise<DmnTableModel>;
+/**
+ * Serialisiert ein `DmnTableModel` zurück nach DMN-XML.
+ *
+ * Wird `originalXml` übergeben, wird dessen Moddle-Baum wiederverwendet — so
+ * bleiben weitere Decisions, DRD/DI, Imports etc. verlustfrei erhalten und nur
+ * die Ziel-Table (per `model.id`) wird ersetzt. Ohne `originalXml` wird ein
+ * minimales, valides Definitions-Dokument neu erzeugt.
+ */
+declare function serializeDmnModel(model: DmnTableModel, originalXml?: string): Promise<string>;
+/** Leere Zelle für eine neue Zeile. */
+declare function emptyRow(model: DmnTableModel): DmnRow;
+declare function addRow(model: DmnTableModel, at?: number): DmnTableModel;
+declare function deleteRow(model: DmnTableModel, rowId: string): DmnTableModel;
+declare function moveRow(model: DmnTableModel, rowId: string, direction: -1 | 1): DmnTableModel;
+declare function updateCell(model: DmnTableModel, rowId: string, colId: string, value: string): DmnTableModel;
+declare function updateAnnotation(model: DmnTableModel, rowId: string, annotation: string): DmnTableModel;
+declare function setHitPolicy(model: DmnTableModel, hitPolicy: HitPolicy, aggregation?: Aggregation): DmnTableModel;
+/** Neue Spalte (Input oder Output) am Ende ihrer Gruppe einfügen. */
+declare function addColumn(model: DmnTableModel, kind: DmnColumn["kind"], partial?: Partial<Omit<DmnColumn, "id" | "kind">>): DmnTableModel;
+declare function updateColumn(model: DmnTableModel, colId: string, patch: Partial<Omit<DmnColumn, "id" | "kind">>): DmnTableModel;
+declare function deleteColumn(model: DmnTableModel, colId: string): DmnTableModel;
+
+/**
+ * Heuristischer FEEL-Linter (regex-basiert) — als **nicht-blockierender Hinweis**
+ * gedacht (Spec §7): valide FEEL außerhalb der Whitelist wird abgelehnt. Ein echter
+ * FEEL-Parser (`feelin`) ist eine spätere Option. Portiert aus
+ * maco-process-studio `useFeelLinter.ts`, aber framework-frei und gegen den
+ * geteilten `DmnColumn`-Vertrag.
+ */
+
+/** Erkannter FEEL-Werttyp (für Token-Färbung im Editor). */
+type FeelValueType = "string" | "number" | "boolean" | "string list" | "number range" | "expression" | "any";
+/** Lint-Ergebnis mit erkanntem Typ (erweitert `FeelLintResult`). */
+interface FeelLintTypedResult extends FeelLintResult {
+    type?: FeelValueType;
+}
+/** Erlaubte Werte aus einem `inputValues`-String der Form `"A","B"` parsen. */
+declare function parseInputValues(inputValues: string): string[];
+/**
+ * Prüft einen FEEL-Zellausdruck heuristisch. `column` liefert (optional) die
+ * erlaubten `inputValues` für eine Whitelist-Validierung.
+ */
+declare function lintFeel(expr: string, column?: Pick<DmnColumn, "inputValues">): FeelLintTypedResult;
+
+interface DmnTableEditorProps {
+    /** Controlled DMN-XML. */
+    value?: string;
+    /** Uncontrolled Start-XML. */
+    defaultValue?: string;
+    /** Wird bei jeder Modelländerung mit serialisiertem XML aufgerufen. */
+    onChange?: (xml: string) => void;
+    /** ⌘S / Speichern-Button. */
+    onSave?: (xml: string) => void | Promise<void>;
+    /** Wählt die zu editierende Decision (Default: erste mit Table). */
+    decisionId?: string;
+    /** Anzeigename (z. B. Prüfprozess-Code). */
+    title?: ReactNode;
+    /** Untertitel/Metadaten. */
+    subtitle?: ReactNode;
+    /** Umschalten zum Experten-Modus (⑥). */
+    onSwitchToExpert?: () => void;
+    /** Optionale Zell-Plugins (z. B. Prüfi-Autocomplete). Default: leer. */
+    cellPlugins?: DmnCellPlugin[];
+    /** Zusätzliche Toolbar-Actions (z. B. KI-Fix). */
+    actionsSlot?: ReactNode;
+    /** Schreibschutz. */
+    readOnly?: boolean;
+    className?: string;
+}
+declare function DmnTableEditor({ value, defaultValue, onChange, onSave, decisionId, title, subtitle, onSwitchToExpert, cellPlugins, actionsSlot, readOnly, className, }: DmnTableEditorProps): react.JSX.Element;
+
+interface DmnExpertEditorProps {
+    /** Controlled DMN-XML. */
+    value?: string;
+    /** Uncontrolled Start-XML. */
+    defaultValue?: string;
+    /** Bei Änderungen (commandStack.changed) mit serialisiertem XML. */
+    onChange?: (xml: string) => void;
+    /** Speichern-Callback. */
+    onSave?: (xml: string) => void | Promise<void>;
+    /** Light/Dark-Steuerung (Default auto via data-theme). */
+    colorScheme?: DiagramColorScheme;
+    /** Zusätzliche Toolbar-Actions. */
+    actionsSlot?: ReactNode;
+    /** Umschalten zur Tabellenansicht (⑤). */
+    onSwitchToTable?: () => void;
+    /** Properties-Panel anzeigen, falls die Pakete vorhanden sind (Default true). */
+    propertiesPanel?: boolean;
+    className?: string;
+}
+declare function DmnExpertEditor({ value, defaultValue, onChange, onSave, colorScheme, actionsSlot, onSwitchToTable, propertiesPanel, className, }: DmnExpertEditorProps): react.JSX.Element;
+
+type DmnEditorMode = "table" | "expert";
+interface DmnEditorProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (xml: string) => void;
+    onSave?: (xml: string) => void | Promise<void>;
+    /** Start-Modus (Default 'table'). */
+    defaultMode?: DmnEditorMode;
+    /** Controlled-Modus. */
+    mode?: DmnEditorMode;
+    onModeChange?: (mode: DmnEditorMode) => void;
+    colorScheme?: DiagramColorScheme;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    cellPlugins?: DmnTableEditorProps["cellPlugins"];
+    actionsSlot?: ReactNode;
+    decisionId?: string;
+    className?: string;
+}
+declare function DmnEditor({ value, defaultValue, onChange, onSave, defaultMode, mode: controlledMode, onModeChange, colorScheme, title, subtitle, cellPlugins, actionsSlot, decisionId, className, }: DmnEditorProps): react.JSX.Element;
+
+export { type Aggregation, type DiagramColorScheme, type DiagramColors, type DmnCellPlugin, type DmnColumn, type DmnColumnKind, type DmnDecisionRef, DmnEditor, type DmnEditorMode, type DmnEditorProps, DmnExpertEditor, type DmnExpertEditorProps, type DmnRow, DmnTableEditor, type DmnTableEditorProps, type DmnTableModel, type FeelLintResult, type FeelLintTypedResult, type FeelValueType, type HitPolicy, type ParseOptions, addColumn, addRow, deleteColumn, deleteRow, emptyRow, getDiagramColors, isDarkMode, lintFeel, listDecisions, makeId, moveRow, onThemeChange, parseDmnModel, parseInputValues, readToken, serializeDmnModel, setHitPolicy, updateAnnotation, updateCell, updateColumn };