@bpmnkit/core 0.0.8

package/dist/bpmn/zeebe-extensions.d.ts

@@ -0,0 +1,72 @@
+import type { XmlElement } from "../types/xml-element.js";
+/** Zeebe task definition extension. */
+export interface ZeebeTaskDefinition {
+    type: string;
+    retries?: string;
+}
+/** A single Zeebe IO mapping entry. */
+export interface ZeebeIoMappingEntry {
+    source: string;
+    target: string;
+}
+/** Zeebe IO mapping extension. */
+export interface ZeebeIoMapping {
+    inputs: ZeebeIoMappingEntry[];
+    outputs: ZeebeIoMappingEntry[];
+}
+/** A single Zeebe task header entry. */
+export interface ZeebeTaskHeaderEntry {
+    key: string;
+    value: string;
+}
+/** Zeebe task headers extension. */
+export interface ZeebeTaskHeaders {
+    headers: ZeebeTaskHeaderEntry[];
+}
+/** A single Zeebe property entry. */
+export interface ZeebePropertyEntry {
+    name: string;
+    value: string;
+}
+/** Zeebe properties extension. */
+export interface ZeebeProperties {
+    properties: ZeebePropertyEntry[];
+}
+/** Zeebe ad-hoc sub-process extension (AI Agent job worker pattern). */
+export interface ZeebeAdHoc {
+    /** Variable name that collects tool call results from child tasks. */
+    outputCollection?: string;
+    /** FEEL expression mapping each child task's result into the collection. */
+    outputElement?: string;
+    /** FEEL expression selecting which child element IDs to activate (BPMN-native mode). */
+    activeElementsCollection?: string;
+}
+/** Zeebe form definition extension for user tasks. */
+export interface ZeebeFormDefinition {
+    /** ID of the Camunda Form linked to this user task. */
+    formId: string;
+}
+/** Zeebe called decision extension for business rule tasks. */
+export interface ZeebeCalledDecision {
+    /** ID of the DMN decision to invoke. */
+    decisionId: string;
+    /** Process variable that receives the decision result. */
+    resultVariable: string;
+}
+/** Collected Zeebe extensions on a service task. */
+export interface ZeebeExtensions {
+    taskDefinition?: ZeebeTaskDefinition;
+    ioMapping?: ZeebeIoMapping;
+    taskHeaders?: ZeebeTaskHeaders;
+    properties?: ZeebeProperties;
+    adHoc?: ZeebeAdHoc;
+    /** Camunda Form linked to a user task (zeebe:formDefinition). */
+    formDefinition?: ZeebeFormDefinition;
+    /** DMN decision invoked by a business rule task (zeebe:calledDecision). */
+    calledDecision?: ZeebeCalledDecision;
+    /** Unrecognized extension elements preserved for roundtrip. */
+    unknownElements?: XmlElement[];
+}
+/** Convert Zeebe extensions to XmlElement array for the BPMN model. */
+export declare function zeebeExtensionsToXmlElements(extensions: ZeebeExtensions): XmlElement[];
+//# sourceMappingURL=zeebe-extensions.d.ts.map

package/dist/bpmn/zeebe-extensions.js

@@ -0,0 +1,96 @@
+/** Convert Zeebe extensions to XmlElement array for the BPMN model. */
+export function zeebeExtensionsToXmlElements(extensions) {
+    const elements = [];
+    if (extensions.taskDefinition) {
+        const attrs = {
+            type: extensions.taskDefinition.type,
+        };
+        if (extensions.taskDefinition.retries !== undefined) {
+            attrs.retries = extensions.taskDefinition.retries;
+        }
+        elements.push({
+            name: "zeebe:taskDefinition",
+            attributes: attrs,
+            children: [],
+        });
+    }
+    if (extensions.ioMapping) {
+        const children = [];
+        for (const input of extensions.ioMapping.inputs) {
+            children.push({
+                name: "zeebe:input",
+                attributes: { source: input.source, target: input.target },
+                children: [],
+            });
+        }
+        for (const output of extensions.ioMapping.outputs) {
+            children.push({
+                name: "zeebe:output",
+                attributes: { source: output.source, target: output.target },
+                children: [],
+            });
+        }
+        elements.push({
+            name: "zeebe:ioMapping",
+            attributes: {},
+            children,
+        });
+    }
+    if (extensions.taskHeaders) {
+        const children = extensions.taskHeaders.headers.map((header) => ({
+            name: "zeebe:header",
+            attributes: { key: header.key, value: header.value },
+            children: [],
+        }));
+        elements.push({
+            name: "zeebe:taskHeaders",
+            attributes: {},
+            children,
+        });
+    }
+    if (extensions.properties) {
+        const children = extensions.properties.properties.map((prop) => ({
+            name: "zeebe:property",
+            attributes: { name: prop.name, value: prop.value },
+            children: [],
+        }));
+        elements.push({
+            name: "zeebe:properties",
+            attributes: {},
+            children,
+        });
+    }
+    if (extensions.adHoc) {
+        const attrs = {};
+        const { outputCollection, outputElement, activeElementsCollection } = extensions.adHoc;
+        if (outputCollection)
+            attrs.outputCollection = outputCollection;
+        if (outputElement)
+            attrs.outputElement = outputElement;
+        if (activeElementsCollection)
+            attrs.activeElementsCollection = activeElementsCollection;
+        elements.push({ name: "zeebe:adHoc", attributes: attrs, children: [] });
+    }
+    if (extensions.formDefinition) {
+        elements.push({
+            name: "zeebe:formDefinition",
+            attributes: { formId: extensions.formDefinition.formId },
+            children: [],
+        });
+    }
+    if (extensions.calledDecision) {
+        elements.push({
+            name: "zeebe:calledDecision",
+            attributes: {
+                decisionId: extensions.calledDecision.decisionId,
+                resultVariable: extensions.calledDecision.resultVariable,
+            },
+            children: [],
+        });
+    }
+    if (extensions.unknownElements) {
+        elements.push(...extensions.unknownElements);
+    }
+    return elements;
+}
+//# sourceMappingURL=zeebe-extensions.js.map

package/dist/dmn/compact.d.ts

@@ -0,0 +1,44 @@
+import type { DmnAggregation, DmnDefinitions, DmnTypeRef, HitPolicy } from "./dmn-model.js";
+export interface CompactDmnInput {
+    id: string;
+    label?: string;
+    expression?: string;
+    typeRef?: DmnTypeRef;
+}
+export interface CompactDmnOutput {
+    id: string;
+    label?: string;
+    name?: string;
+    typeRef?: DmnTypeRef;
+}
+export interface CompactDmnRule {
+    id: string;
+    inputs: string[];
+    outputs: string[];
+    description?: string;
+}
+export interface CompactDmnDecision {
+    id: string;
+    name?: string;
+    hitPolicy?: HitPolicy;
+    aggregation?: DmnAggregation;
+    inputs: CompactDmnInput[];
+    outputs: CompactDmnOutput[];
+    rules: CompactDmnRule[];
+    /** IDs of decisions or inputData this decision requires */
+    requires?: string[];
+}
+export interface CompactDmn {
+    id: string;
+    name: string;
+    decisions: CompactDmnDecision[];
+    inputData: Array<{
+        id: string;
+        name?: string;
+    }>;
+}
+/** Convert a DmnDefinitions model to a token-efficient CompactDmn representation. */
+export declare function compactifyDmn(defs: DmnDefinitions): CompactDmn;
+/** Convert a CompactDmn back to a full DmnDefinitions model with auto-layout applied. */
+export declare function expandDmn(compact: CompactDmn): DmnDefinitions;
+//# sourceMappingURL=compact.d.ts.map

package/dist/dmn/compact.js

@@ -0,0 +1,125 @@
+import { generateId } from "../types/id-generator.js";
+import { layoutDmn } from "./dmn-layout.js";
+// ── Compactify ────────────────────────────────────────────────────────────────
+/** Convert a DmnDefinitions model to a token-efficient CompactDmn representation. */
+export function compactifyDmn(defs) {
+    const decisions = defs.decisions.map((d) => {
+        const requires = [];
+        for (const req of d.informationRequirements) {
+            const src = req.requiredDecision ?? req.requiredInput;
+            if (src)
+                requires.push(src);
+        }
+        const dt = d.decisionTable;
+        return {
+            id: d.id,
+            name: d.name,
+            hitPolicy: dt?.hitPolicy,
+            aggregation: dt?.aggregation,
+            inputs: (dt?.inputs ?? []).map((i) => ({
+                id: i.id,
+                label: i.label,
+                expression: i.inputExpression.text,
+                typeRef: i.inputExpression.typeRef,
+            })),
+            outputs: (dt?.outputs ?? []).map((o) => ({
+                id: o.id,
+                label: o.label,
+                name: o.name,
+                typeRef: o.typeRef,
+            })),
+            rules: (dt?.rules ?? []).map((r) => ({
+                id: r.id,
+                inputs: r.inputEntries.map((e) => e.text),
+                outputs: r.outputEntries.map((e) => e.text),
+                description: r.description,
+            })),
+            requires: requires.length > 0 ? requires : undefined,
+        };
+    });
+    return {
+        id: defs.id,
+        name: defs.name,
+        decisions,
+        inputData: defs.inputData.map((d) => ({ id: d.id, name: d.name })),
+    };
+}
+// ── Expand ────────────────────────────────────────────────────────────────────
+/** Convert a CompactDmn back to a full DmnDefinitions model with auto-layout applied. */
+export function expandDmn(compact) {
+    const inputData = compact.inputData.map((d) => ({ id: d.id, name: d.name }));
+    const decisions = compact.decisions.map((cd) => {
+        // Build requirement links
+        const informationRequirements = (cd.requires ?? []).map((srcId) => ({
+            id: generateId("InformationRequirement"),
+            requiredDecision: compact.decisions.some((d) => d.id === srcId) ? srcId : undefined,
+            requiredInput: compact.inputData.some((d) => d.id === srcId) ? srcId : undefined,
+        }));
+        // Build decision table
+        let decisionTable;
+        if (cd.inputs.length > 0 || cd.outputs.length > 0 || cd.rules.length > 0) {
+            const inputs = cd.inputs.map((i) => ({
+                id: i.id,
+                label: i.label,
+                inputExpression: {
+                    id: generateId("inputExpression"),
+                    typeRef: i.typeRef,
+                    text: i.expression,
+                },
+            }));
+            const outputs = cd.outputs.map((o) => ({
+                id: o.id,
+                label: o.label,
+                name: o.name,
+                typeRef: o.typeRef,
+            }));
+            const rules = cd.rules.map((r) => ({
+                id: r.id,
+                description: r.description,
+                inputEntries: r.inputs.map((text, idx) => ({
+                    id: generateId(`inputEntry_${idx}`),
+                    text,
+                })),
+                outputEntries: r.outputs.map((text, idx) => ({
+                    id: generateId(`outputEntry_${idx}`),
+                    text,
+                })),
+            }));
+            decisionTable = {
+                id: generateId("decisionTable"),
+                hitPolicy: cd.hitPolicy,
+                aggregation: cd.aggregation,
+                inputs,
+                outputs,
+                rules,
+            };
+        }
+        return {
+            id: cd.id,
+            name: cd.name,
+            decisionTable,
+            informationRequirements,
+            knowledgeRequirements: [],
+            authorityRequirements: [],
+        };
+    });
+    const defs = {
+        id: compact.id,
+        name: compact.name,
+        namespace: "http://bpmn.io/schema/dmn",
+        namespaces: {
+            "": "https://www.omg.org/spec/DMN/20191111/MODEL/",
+            dmndi: "https://www.omg.org/spec/DMN/20191111/DMNDI/",
+            dc: "http://www.omg.org/spec/DMN/20180521/DC/",
+        },
+        modelerAttributes: {},
+        decisions,
+        inputData,
+        knowledgeSources: [],
+        businessKnowledgeModels: [],
+        textAnnotations: [],
+        associations: [],
+    };
+    return layoutDmn(defs);
+}
+//# sourceMappingURL=compact.js.map

package/dist/dmn/dmn-builder.d.ts

@@ -0,0 +1,59 @@
+import type { DmnDefinitions, DmnTypeRef, HitPolicy } from "./dmn-model.js";
+/** Options for creating a decision table input column. */
+export interface InputOptions {
+    /** Display label for the input column. */
+    label?: string;
+    /** FEEL expression for the input (e.g., variable name). */
+    expression: string;
+    /** Data type of the input. */
+    typeRef?: DmnTypeRef;
+}
+/** Options for creating a decision table output column. */
+export interface OutputOptions {
+    /** Display label for the output column. */
+    label?: string;
+    /** Variable name for the output. */
+    name: string;
+    /** Data type of the output. */
+    typeRef?: DmnTypeRef;
+}
+/** Options for creating a decision table rule (row). */
+export interface RuleOptions {
+    /** Human-readable description/annotation for this rule. */
+    description?: string;
+    /** Input entry values (unary tests), one per input column. */
+    inputs: string[];
+    /** Output entry values (literal expressions), one per output column. */
+    outputs: string[];
+}
+/** Fluent builder for constructing DMN decision tables. */
+export declare class DecisionTableBuilder {
+    private readonly decisionId;
+    private decisionName;
+    private tableId;
+    private hitPolicyValue;
+    private readonly inputColumns;
+    private readonly outputColumns;
+    private readonly ruleRows;
+    constructor(decisionId: string);
+    /** Set the display name for this decision. */
+    name(name: string): this;
+    /** Set the hit policy for this decision table. */
+    hitPolicy(policy: HitPolicy): this;
+    /** Add an input column to the decision table. */
+    input(options: InputOptions): this;
+    /** Add an output column to the decision table. */
+    output(options: OutputOptions): this;
+    /**
+     * Add a rule (row) to the decision table.
+     *
+     * @throws {ValidationError} If the number of input or output values does not
+     *   match the number of columns declared with `.input()` / `.output()`.
+     */
+    rule(options: RuleOptions): this;
+    /** Build the DMN definitions model. */
+    build(): DmnDefinitions;
+    /** Build and export as DMN XML string. */
+    toXml(): string;
+}
+//# sourceMappingURL=dmn-builder.d.ts.map

package/dist/dmn/dmn-builder.js

@@ -0,0 +1,144 @@
+import { ValidationError } from "../errors.js";
+import { generateId } from "../types/id-generator.js";
+import { serializeDmn } from "./dmn-serializer.js";
+const DMN_MODEL_NS = "https://www.omg.org/spec/DMN/20191111/MODEL/";
+const DMN_DI_NS = "https://www.omg.org/spec/DMN/20191111/DMNDI/";
+const DC_NS = "http://www.omg.org/spec/DMN/20180521/DC/";
+const MODELER_NS = "http://camunda.org/schema/modeler/1.0";
+const DEFAULT_NAMESPACE = "http://camunda.org/schema/1.0/dmn";
+/** Fluent builder for constructing DMN decision tables. */
+export class DecisionTableBuilder {
+    decisionId;
+    decisionName;
+    tableId;
+    hitPolicyValue = "UNIQUE";
+    inputColumns = [];
+    outputColumns = [];
+    ruleRows = [];
+    constructor(decisionId) {
+        this.decisionId = decisionId;
+        this.decisionName = decisionId;
+        this.tableId = generateId("DecisionTable");
+    }
+    /** Set the display name for this decision. */
+    name(name) {
+        this.decisionName = name;
+        return this;
+    }
+    /** Set the hit policy for this decision table. */
+    hitPolicy(policy) {
+        this.hitPolicyValue = policy;
+        return this;
+    }
+    /** Add an input column to the decision table. */
+    input(options) {
+        const inputId = generateId("Input");
+        const exprId = generateId("InputExpression");
+        this.inputColumns.push({
+            id: inputId,
+            label: options.label,
+            inputExpression: {
+                id: exprId,
+                typeRef: options.typeRef,
+                text: options.expression,
+            },
+        });
+        return this;
+    }
+    /** Add an output column to the decision table. */
+    output(options) {
+        const outputId = generateId("Output");
+        this.outputColumns.push({
+            id: outputId,
+            label: options.label,
+            name: options.name,
+            typeRef: options.typeRef,
+        });
+        return this;
+    }
+    /**
+     * Add a rule (row) to the decision table.
+     *
+     * @throws {ValidationError} If the number of input or output values does not
+     *   match the number of columns declared with `.input()` / `.output()`.
+     */
+    rule(options) {
+        if (options.inputs.length !== this.inputColumns.length) {
+            throw new ValidationError(`Rule has ${options.inputs.length} inputs but table has ${this.inputColumns.length} input columns`);
+        }
+        if (options.outputs.length !== this.outputColumns.length) {
+            throw new ValidationError(`Rule has ${options.outputs.length} outputs but table has ${this.outputColumns.length} output columns`);
+        }
+        const inputEntries = options.inputs.map((text) => ({
+            id: generateId("UnaryTests"),
+            text,
+        }));
+        const outputEntries = options.outputs.map((text) => ({
+            id: generateId("LiteralExpression"),
+            text,
+        }));
+        this.ruleRows.push({
+            id: generateId("DecisionRule"),
+            description: options.description,
+            inputEntries,
+            outputEntries,
+        });
+        return this;
+    }
+    /** Build the DMN definitions model. */
+    build() {
+        const decisionTable = {
+            id: this.tableId,
+            hitPolicy: this.hitPolicyValue === "UNIQUE" ? undefined : this.hitPolicyValue,
+            inputs: this.inputColumns,
+            outputs: this.outputColumns,
+            rules: this.ruleRows,
+        };
+        const decision = {
+            id: this.decisionId,
+            name: this.decisionName,
+            decisionTable,
+            informationRequirements: [],
+            knowledgeRequirements: [],
+            authorityRequirements: [],
+        };
+        const diagram = {
+            shapes: [
+                {
+                    dmnElementRef: this.decisionId,
+                    bounds: { x: 160, y: 100, width: 180, height: 80 },
+                },
+            ],
+            edges: [],
+        };
+        return {
+            id: generateId("Definitions"),
+            name: "DRD",
+            namespace: DEFAULT_NAMESPACE,
+            exporter: "bpmn-sdk",
+            exporterVersion: "0.0.1",
+            namespaces: {
+                "": DMN_MODEL_NS,
+                dmndi: DMN_DI_NS,
+                dc: DC_NS,
+                modeler: MODELER_NS,
+            },
+            modelerAttributes: {
+                executionPlatform: "Camunda Cloud",
+                executionPlatformVersion: "8.5.0",
+            },
+            decisions: [decision],
+            inputData: [],
+            knowledgeSources: [],
+            businessKnowledgeModels: [],
+            textAnnotations: [],
+            associations: [],
+            diagram,
+        };
+    }
+    /** Build and export as DMN XML string. */
+    toXml() {
+        return serializeDmn(this.build());
+    }
+}
+//# sourceMappingURL=dmn-builder.js.map

package/dist/dmn/dmn-layout.d.ts

@@ -0,0 +1,57 @@
+import type { DmnDefinitions } from "./dmn-model.js";
+declare const SIZES: {
+    readonly decision: {
+        readonly width: 180;
+        readonly height: 80;
+    };
+    readonly inputData: {
+        readonly width: 125;
+        readonly height: 45;
+    };
+    readonly knowledgeSource: {
+        readonly width: 100;
+        readonly height: 63;
+    };
+    readonly businessKnowledgeModel: {
+        readonly width: 160;
+        readonly height: 80;
+    };
+};
+type NodeKind = keyof typeof SIZES;
+/**
+ * Auto-layout a DMN definitions object.
+ * Assigns DMNDI diagram positions to all DRG elements using a left-to-right
+ * layered layout based on the requirement DAG.
+ */
+export declare function layoutDmn(defs: DmnDefinitions): DmnDefinitions;
+export interface DmnElementPosition {
+    id: string;
+    name?: string;
+    kind: NodeKind;
+    ref: {
+        cx: number;
+        cy: number;
+    };
+    auto: {
+        cx: number;
+        cy: number;
+    };
+    delta: {
+        dx: number;
+        dy: number;
+    };
+    distance: number;
+}
+export interface DmnBenchmarkResult {
+    fileName: string;
+    elementCount: number;
+    matchedCount: number;
+    avgDistance: number;
+    p90Distance: number;
+    maxDistance: number;
+    elements: DmnElementPosition[];
+}
+/** Parse the reference layout, strip DMNDI, run auto-layout, and compare. */
+export declare function benchmarkDmnLayout(xml: string, fileName: string): DmnBenchmarkResult;
+export {};
+//# sourceMappingURL=dmn-layout.d.ts.map