@bpmnkit/core 0.0.8

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

@@ -0,0 +1,4 @@
+import type { DmnDefinitions } from "./dmn-model.js";
+/** Serialize a DmnDefinitions model to a DMN XML string. */
+export declare function serializeDmn(definitions: DmnDefinitions): string;
+//# sourceMappingURL=dmn-serializer.d.ts.map

package/dist/dmn/dmn-serializer.js

@@ -0,0 +1,296 @@
+import { serializeXml } from "../xml/xml-parser.js";
+function textElement(text) {
+    return { name: "text", attributes: {}, children: [], text };
+}
+function serializeInput(input) {
+    const exprAttrs = { id: input.inputExpression.id };
+    if (input.inputExpression.typeRef) {
+        exprAttrs.typeRef = input.inputExpression.typeRef;
+    }
+    const exprChildren = [];
+    if (input.inputExpression.text) {
+        exprChildren.push(textElement(input.inputExpression.text));
+    }
+    const inputAttrs = { id: input.id };
+    if (input.label)
+        inputAttrs.label = input.label;
+    return {
+        name: "input",
+        attributes: inputAttrs,
+        children: [
+            {
+                name: "inputExpression",
+                attributes: exprAttrs,
+                children: exprChildren,
+            },
+        ],
+    };
+}
+function serializeOutput(output) {
+    const attrs = { id: output.id };
+    if (output.label)
+        attrs.label = output.label;
+    if (output.name)
+        attrs.name = output.name;
+    if (output.typeRef)
+        attrs.typeRef = output.typeRef;
+    return { name: "output", attributes: attrs, children: [] };
+}
+function serializeRule(rule) {
+    const children = [];
+    if (rule.description) {
+        children.push({
+            name: "description",
+            attributes: {},
+            children: [],
+            text: rule.description,
+        });
+    }
+    for (const entry of rule.inputEntries) {
+        children.push({
+            name: "inputEntry",
+            attributes: { id: entry.id },
+            children: [textElement(entry.text)],
+        });
+    }
+    for (const entry of rule.outputEntries) {
+        children.push({
+            name: "outputEntry",
+            attributes: { id: entry.id },
+            children: [textElement(entry.text)],
+        });
+    }
+    return {
+        name: "rule",
+        attributes: { id: rule.id },
+        children,
+    };
+}
+function serializeDecisionTable(table) {
+    const attrs = { id: table.id };
+    if (table.hitPolicy && table.hitPolicy !== "UNIQUE") {
+        attrs.hitPolicy = table.hitPolicy;
+    }
+    if (table.aggregation)
+        attrs.aggregation = table.aggregation;
+    const children = [
+        ...table.inputs.map(serializeInput),
+        ...table.outputs.map(serializeOutput),
+        ...table.rules.map(serializeRule),
+    ];
+    return { name: "decisionTable", attributes: attrs, children };
+}
+function serializeInformationRequirements(decision) {
+    return decision.informationRequirements.map((req) => {
+        const child = req.requiredDecision
+            ? { name: "requiredDecision", attributes: { href: `#${req.requiredDecision}` }, children: [] }
+            : { name: "requiredInput", attributes: { href: `#${req.requiredInput}` }, children: [] };
+        return {
+            name: "informationRequirement",
+            attributes: { id: req.id },
+            children: [child],
+        };
+    });
+}
+function serializeKnowledgeRequirements(reqs) {
+    return reqs.map((req) => ({
+        name: "knowledgeRequirement",
+        attributes: { id: req.id },
+        children: [
+            {
+                name: "requiredKnowledge",
+                attributes: { href: `#${req.requiredKnowledge}` },
+                children: [],
+            },
+        ],
+    }));
+}
+function serializeAuthorityRequirements(reqs) {
+    return reqs.map((req) => {
+        let child;
+        if (req.requiredDecision) {
+            child = {
+                name: "requiredDecision",
+                attributes: { href: `#${req.requiredDecision}` },
+                children: [],
+            };
+        }
+        else if (req.requiredInput) {
+            child = {
+                name: "requiredInput",
+                attributes: { href: `#${req.requiredInput}` },
+                children: [],
+            };
+        }
+        else {
+            child = {
+                name: "requiredAuthority",
+                attributes: { href: `#${req.requiredAuthority ?? ""}` },
+                children: [],
+            };
+        }
+        return {
+            name: "authorityRequirement",
+            attributes: { id: req.id },
+            children: [child],
+        };
+    });
+}
+function serializeDecision(decision) {
+    const children = [];
+    if (decision.extensionElements && decision.extensionElements.length > 0) {
+        children.push({
+            name: "extensionElements",
+            attributes: {},
+            children: decision.extensionElements,
+        });
+    }
+    children.push(...serializeInformationRequirements(decision));
+    children.push(...serializeKnowledgeRequirements(decision.knowledgeRequirements));
+    children.push(...serializeAuthorityRequirements(decision.authorityRequirements));
+    if (decision.decisionTable) {
+        children.push(serializeDecisionTable(decision.decisionTable));
+    }
+    const attrs = { id: decision.id };
+    if (decision.name)
+        attrs.name = decision.name;
+    return { name: "decision", attributes: attrs, children };
+}
+function serializeInputData(inputData) {
+    const attrs = { id: inputData.id };
+    if (inputData.name)
+        attrs.name = inputData.name;
+    return { name: "inputData", attributes: attrs, children: [] };
+}
+function serializeKnowledgeSource(ks) {
+    const attrs = { id: ks.id };
+    if (ks.name)
+        attrs.name = ks.name;
+    return {
+        name: "knowledgeSource",
+        attributes: attrs,
+        children: serializeAuthorityRequirements(ks.authorityRequirements),
+    };
+}
+function serializeBusinessKnowledgeModel(bkm) {
+    const attrs = { id: bkm.id };
+    if (bkm.name)
+        attrs.name = bkm.name;
+    return {
+        name: "businessKnowledgeModel",
+        attributes: attrs,
+        children: [
+            ...serializeKnowledgeRequirements(bkm.knowledgeRequirements),
+            ...serializeAuthorityRequirements(bkm.authorityRequirements),
+        ],
+    };
+}
+function serializeTextAnnotation(ann) {
+    const children = [];
+    if (ann.text) {
+        children.push(textElement(ann.text));
+    }
+    return { name: "textAnnotation", attributes: { id: ann.id }, children };
+}
+function serializeAssociation(assoc) {
+    return {
+        name: "association",
+        attributes: {
+            id: assoc.id,
+            sourceRef: `#${assoc.sourceRef}`,
+            targetRef: `#${assoc.targetRef}`,
+        },
+        children: [],
+    };
+}
+function serializeDiagram(diagram) {
+    const shapes = diagram.shapes.map((shape) => ({
+        name: "dmndi:DMNShape",
+        attributes: { dmnElementRef: shape.dmnElementRef },
+        children: [
+            {
+                name: "dc:Bounds",
+                attributes: {
+                    height: String(shape.bounds.height),
+                    width: String(shape.bounds.width),
+                    x: String(shape.bounds.x),
+                    y: String(shape.bounds.y),
+                },
+                children: [],
+            },
+        ],
+    }));
+    const edges = diagram.edges.map((edge) => ({
+        name: "dmndi:DMNEdge",
+        attributes: { dmnElementRef: edge.dmnElementRef },
+        children: edge.waypoints.map((wp) => ({
+            name: "di:waypoint",
+            attributes: { x: String(wp.x), y: String(wp.y) },
+            children: [],
+        })),
+    }));
+    return {
+        name: "dmndi:DMNDI",
+        attributes: {},
+        children: [
+            {
+                name: "dmndi:DMNDiagram",
+                attributes: {},
+                children: [...shapes, ...edges],
+            },
+        ],
+    };
+}
+/** Serialize a DmnDefinitions model to a DMN XML string. */
+export function serializeDmn(definitions) {
+    const attrs = {};
+    // Namespace declarations
+    for (const [prefix, uri] of Object.entries(definitions.namespaces)) {
+        if (prefix === "") {
+            attrs.xmlns = uri;
+        }
+        else {
+            attrs[`xmlns:${prefix}`] = uri;
+        }
+    }
+    attrs.id = definitions.id;
+    attrs.name = definitions.name;
+    attrs.namespace = definitions.namespace;
+    if (definitions.exporter)
+        attrs.exporter = definitions.exporter;
+    if (definitions.exporterVersion)
+        attrs.exporterVersion = definitions.exporterVersion;
+    // Modeler attributes
+    for (const [key, value] of Object.entries(definitions.modelerAttributes)) {
+        attrs[`modeler:${key}`] = value;
+    }
+    const children = [];
+    for (const decision of definitions.decisions) {
+        children.push(serializeDecision(decision));
+    }
+    for (const id of definitions.inputData) {
+        children.push(serializeInputData(id));
+    }
+    for (const ks of definitions.knowledgeSources) {
+        children.push(serializeKnowledgeSource(ks));
+    }
+    for (const bkm of definitions.businessKnowledgeModels) {
+        children.push(serializeBusinessKnowledgeModel(bkm));
+    }
+    for (const ann of definitions.textAnnotations) {
+        children.push(serializeTextAnnotation(ann));
+    }
+    for (const assoc of definitions.associations) {
+        children.push(serializeAssociation(assoc));
+    }
+    if (definitions.diagram) {
+        children.push(serializeDiagram(definitions.diagram));
+    }
+    const root = {
+        name: "definitions",
+        attributes: attrs,
+        children,
+    };
+    return serializeXml(root);
+}
+//# sourceMappingURL=dmn-serializer.js.map

package/dist/dmn/index.d.ts

@@ -0,0 +1,28 @@
+import { compactifyDmn, expandDmn } from "./compact.js";
+import { DecisionTableBuilder } from "./dmn-builder.js";
+import type { DmnDefinitions } from "./dmn-model.js";
+export { layoutDmn, benchmarkDmnLayout } from "./dmn-layout.js";
+export type { DmnBenchmarkResult, DmnElementPosition } from "./dmn-layout.js";
+export { compactifyDmn, expandDmn } from "./compact.js";
+export type { CompactDmn, CompactDmnDecision, CompactDmnInput, CompactDmnOutput, CompactDmnRule, } from "./compact.js";
+/** Entry point for DMN decision table operations. */
+export declare const Dmn: {
+    /** Create a new DMN decision table using the fluent builder API. */
+    readonly createDecisionTable: (decisionId: string) => DecisionTableBuilder;
+    /** Parse a DMN XML string into a typed model. */
+    readonly parse: (xml: string) => DmnDefinitions;
+    /** Export a typed DMN model to XML string. */
+    readonly export: (definitions: DmnDefinitions) => string;
+    /**
+     * Returns a minimal valid DMN definitions object with one empty decision table.
+     * Useful for "New Decision" actions.
+     */
+    readonly makeEmpty: () => DmnDefinitions;
+    /** Auto-layout a DMN definitions object, assigning DMNDI positions. */
+    readonly layout: (definitions: DmnDefinitions) => DmnDefinitions;
+    /** Convert a DmnDefinitions to a token-efficient compact representation. */
+    readonly compactify: (definitions: DmnDefinitions) => ReturnType<typeof compactifyDmn>;
+    /** Convert a compact DMN representation back to DmnDefinitions with auto-layout. */
+    readonly expand: (compact: Parameters<typeof expandDmn>[0]) => DmnDefinitions;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/dmn/index.js

@@ -0,0 +1,51 @@
+import { compactifyDmn, expandDmn } from "./compact.js";
+import { DecisionTableBuilder } from "./dmn-builder.js";
+import { layoutDmn } from "./dmn-layout.js";
+import { parseDmn } from "./dmn-parser.js";
+import { serializeDmn } from "./dmn-serializer.js";
+export { layoutDmn, benchmarkDmnLayout } from "./dmn-layout.js";
+export { compactifyDmn, expandDmn } from "./compact.js";
+/** Entry point for DMN decision table operations. */
+export const Dmn = {
+    /** Create a new DMN decision table using the fluent builder API. */
+    createDecisionTable(decisionId) {
+        return new DecisionTableBuilder(decisionId);
+    },
+    /** Parse a DMN XML string into a typed model. */
+    parse(xml) {
+        return parseDmn(xml);
+    },
+    /** Export a typed DMN model to XML string. */
+    export(definitions) {
+        return serializeDmn(definitions);
+    },
+    /**
+     * Returns a minimal valid DMN definitions object with one empty decision table.
+     * Useful for "New Decision" actions.
+     */
+    makeEmpty() {
+        const id = Math.random().toString(36).slice(2, 9);
+        return parseDmn(`<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="https://www.omg.org/spec/DMN/20191111/MODEL/"
+  id="Definitions_${id}" name="New Decision" namespace="http://bpmn.io/schema/dmn">
+  <decision id="Decision_${id}" name="Decision 1">
+    <decisionTable id="decisionTable_${id}" hitPolicy="UNIQUE">
+      <output id="output_${id}" label="Result" name="result" typeRef="string"/>
+    </decisionTable>
+  </decision>
+</definitions>`);
+    },
+    /** Auto-layout a DMN definitions object, assigning DMNDI positions. */
+    layout(definitions) {
+        return layoutDmn(definitions);
+    },
+    /** Convert a DmnDefinitions to a token-efficient compact representation. */
+    compactify(definitions) {
+        return compactifyDmn(definitions);
+    },
+    /** Convert a compact DMN representation back to DmnDefinitions with auto-layout. */
+    expand(compact) {
+        return expandDmn(compact);
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/errors.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Typed error codes for all errors thrown by `@bpmnkit/core`.
+ *
+ * Use these values to programmatically distinguish error causes:
+ * ```typescript
+ * import { ParseError, ErrorCode } from "@bpmnkit/core"
+ *
+ * try {
+ *   const defs = Bpmn.parse(xml)
+ * } catch (err) {
+ *   if (err instanceof ParseError) {
+ *     console.error(err.code, err.message)
+ *   }
+ * }
+ * ```
+ */
+export type ErrorCode = 
+/** XML could not be parsed or a required attribute was missing. */
+"parse-error"
+/** A builder received an invalid combination of options. */
+ | "validation-error";
+/**
+ * Base class for all errors thrown by `@bpmnkit/core`.
+ *
+ * Always use `instanceof ParseError` or `instanceof ValidationError` rather
+ * than catching the base class, so you can handle each case precisely.
+ */
+export declare class BpmnSdkError extends Error {
+    /** Machine-readable error code. */
+    readonly code: ErrorCode;
+    constructor(message: string, code: ErrorCode);
+}
+/**
+ * Thrown when BPMN or DMN XML cannot be parsed, or when a required attribute
+ * is missing from an element.
+ *
+ * @example
+ * ```typescript
+ * import { Bpmn, ParseError } from "@bpmnkit/core"
+ *
+ * try {
+ *   const defs = Bpmn.parse("<invalid>")
+ * } catch (err) {
+ *   if (err instanceof ParseError) {
+ *     // err.code === "parse-error"
+ *     console.error("Bad BPMN XML:", err.message)
+ *   }
+ * }
+ * ```
+ */
+export declare class ParseError extends BpmnSdkError {
+    constructor(message: string);
+}
+/**
+ * Thrown when a builder receives an invalid combination of options, such as a
+ * DMN rule with the wrong number of input or output entries.
+ *
+ * @example
+ * ```typescript
+ * import { Dmn, ValidationError } from "@bpmnkit/core"
+ *
+ * try {
+ *   Dmn.createDecisionTable("decide")
+ *     .input({ expression: "age" })
+ *     .rule({ inputs: [], outputs: ["adult"] }) // ← wrong count
+ *     .build()
+ * } catch (err) {
+ *   if (err instanceof ValidationError) {
+ *     console.error("Builder error:", err.message)
+ *   }
+ * }
+ * ```
+ */
+export declare class ValidationError extends BpmnSdkError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,66 @@
+/**
+ * Base class for all errors thrown by `@bpmnkit/core`.
+ *
+ * Always use `instanceof ParseError` or `instanceof ValidationError` rather
+ * than catching the base class, so you can handle each case precisely.
+ */
+export class BpmnSdkError extends Error {
+    /** Machine-readable error code. */
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "BpmnSdkError";
+        this.code = code;
+    }
+}
+/**
+ * Thrown when BPMN or DMN XML cannot be parsed, or when a required attribute
+ * is missing from an element.
+ *
+ * @example
+ * ```typescript
+ * import { Bpmn, ParseError } from "@bpmnkit/core"
+ *
+ * try {
+ *   const defs = Bpmn.parse("<invalid>")
+ * } catch (err) {
+ *   if (err instanceof ParseError) {
+ *     // err.code === "parse-error"
+ *     console.error("Bad BPMN XML:", err.message)
+ *   }
+ * }
+ * ```
+ */
+export class ParseError extends BpmnSdkError {
+    constructor(message) {
+        super(message, "parse-error");
+        this.name = "ParseError";
+    }
+}
+/**
+ * Thrown when a builder receives an invalid combination of options, such as a
+ * DMN rule with the wrong number of input or output entries.
+ *
+ * @example
+ * ```typescript
+ * import { Dmn, ValidationError } from "@bpmnkit/core"
+ *
+ * try {
+ *   Dmn.createDecisionTable("decide")
+ *     .input({ expression: "age" })
+ *     .rule({ inputs: [], outputs: ["adult"] }) // ← wrong count
+ *     .build()
+ * } catch (err) {
+ *   if (err instanceof ValidationError) {
+ *     console.error("Builder error:", err.message)
+ *   }
+ * }
+ * ```
+ */
+export class ValidationError extends BpmnSdkError {
+    constructor(message) {
+        super(message, "validation-error");
+        this.name = "ValidationError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/form/compact.d.ts

@@ -0,0 +1,20 @@
+import type { FormDefinition, FormValueOption } from "./form-model.js";
+export interface CompactFormField {
+    type: string;
+    id: string;
+    label?: string;
+    key?: string;
+    required?: boolean;
+    values?: FormValueOption[];
+    /** Nested fields for group and dynamiclist components */
+    fields?: CompactFormField[];
+}
+export interface CompactForm {
+    id: string;
+    fields: CompactFormField[];
+}
+/** Convert a FormDefinition to a token-efficient CompactForm representation. */
+export declare function compactifyForm(def: FormDefinition): CompactForm;
+/** Convert a CompactForm back to a full FormDefinition. */
+export declare function expandForm(compact: CompactForm): FormDefinition;
+//# sourceMappingURL=compact.d.ts.map

package/dist/form/compact.js

@@ -0,0 +1,146 @@
+import { generateId } from "../types/id-generator.js";
+// ── Compactify ────────────────────────────────────────────────────────────────
+function compactifyComponent(c) {
+    const base = { type: c.type, id: c.id };
+    const any = c;
+    if (typeof any.label === "string" && any.label)
+        base.label = any.label;
+    if (typeof any.key === "string" && any.key)
+        base.key = any.key;
+    if (any.validate && typeof any.validate === "object") {
+        const validate = any.validate;
+        if (validate.required === true)
+            base.required = true;
+    }
+    if (Array.isArray(any.values))
+        base.values = any.values;
+    // Nested components
+    if (c.type === "group" || c.type === "dynamiclist") {
+        const nested = "components" in c ? c.components : [];
+        if (nested.length > 0) {
+            base.fields = nested.map(compactifyComponent);
+        }
+    }
+    return base;
+}
+/** Convert a FormDefinition to a token-efficient CompactForm representation. */
+export function compactifyForm(def) {
+    return {
+        id: def.id,
+        fields: def.components.map(compactifyComponent),
+    };
+}
+// ── Expand ────────────────────────────────────────────────────────────────────
+function expandField(f) {
+    switch (f.type) {
+        case "text":
+            return { type: "text", id: f.id, text: f.label ?? "" };
+        case "textfield":
+            return {
+                type: "textfield",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "textarea":
+            return {
+                type: "textarea",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "number":
+            return {
+                type: "number",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "select":
+            return {
+                type: "select",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                values: f.values,
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "radio":
+            return {
+                type: "radio",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                values: f.values ?? [],
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "checkbox":
+            return {
+                type: "checkbox",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "checklist":
+            return {
+                type: "checklist",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                values: f.values ?? [],
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "taglist":
+            return {
+                type: "taglist",
+                id: f.id,
+                label: f.label ?? "",
+                key: f.key ?? generateId("field"),
+                values: f.values,
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "datetime":
+            return {
+                type: "datetime",
+                id: f.id,
+                key: f.key ?? generateId("field"),
+                validate: f.required ? { required: true } : undefined,
+            };
+        case "button":
+            return { type: "button", id: f.id, label: f.label ?? "Submit" };
+        case "separator":
+            return { type: "separator", id: f.id };
+        case "spacer":
+            return { type: "spacer", id: f.id };
+        case "group":
+            return {
+                type: "group",
+                id: f.id,
+                label: f.label ?? "",
+                components: (f.fields ?? []).map(expandField),
+            };
+        case "dynamiclist":
+            return {
+                type: "dynamiclist",
+                id: f.id,
+                label: f.label,
+                components: (f.fields ?? []).map(expandField),
+            };
+        default:
+            return { type: f.type, id: f.id };
+    }
+}
+/** Convert a CompactForm back to a full FormDefinition. */
+export function expandForm(compact) {
+    return {
+        id: compact.id,
+        type: "default",
+        schemaVersion: 16,
+        components: compact.fields.map(expandField),
+    };
+}
+//# sourceMappingURL=compact.js.map