@bpmn-ld/bpmn-ld 0.0.0-stage → 0.2.0

package/dist/eval/checks.d.ts

@@ -0,0 +1,19 @@
+export interface Check {
+    name: string;
+    run: (file: string) => Promise<string[]>;
+}
+export interface Failure {
+    check: string;
+    message: string;
+}
+export interface FileResult {
+    file: string;
+    failures: Failure[];
+}
+export declare const CHECKS: Check[];
+export declare const EXPLANATION_CHECKS: Check[];
+export declare const MODIFICATION_CHECKS: Check[];
+export declare const evaluateFile: (file: string, checks?: Check[]) => Promise<FileResult>;
+export declare const evaluateOutputs: (dir: string, checks?: Check[]) => Promise<FileResult[]>;
+export declare const evaluateExplanations: (dir: string, checks?: Check[]) => Promise<FileResult[]>;
+export declare const evaluateModifications: (dir: string, checks?: Check[]) => Promise<FileResult[]>;

package/dist/eval/checks.js

@@ -0,0 +1,252 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { convert } from "../convert/convert.js";
+import { analyze } from "../analyze/analyze.js";
+import { checkXml } from "../check-xml/check.js";
+import { layoutAndExport } from "../export/layout-export.js";
+import { ExportInputError } from "../export/export.js";
+import { layoutDocument, LayoutInputError } from "../layout/layout.js";
+import { compileSchema, validateWithSchema } from "../schema-validate.js";
+import { validateShacl } from "../shacl.js";
+import { validateExample } from "../validate.js";
+const WARNING_PREFIX = "warning ";
+const severityPrefix = (severity) => (severity === "error" ? "" : WARNING_PREFIX);
+const validateSchema = compileSchema();
+const structural = {
+    name: "structural",
+    run: async (file) => (await validateExample(file)).errors,
+};
+const schema = {
+    name: "schema",
+    run: async (file) => validateWithSchema(JSON.parse(readFileSync(file, "utf8")), validateSchema),
+};
+const shacl = {
+    name: "shacl",
+    run: async (file) => {
+        const result = await validateShacl(file);
+        const messages = result.violations.map((v) => `${v.focusNode} violates ${v.sourceShape}`);
+        if (!result.conforms && messages.length === 0)
+            messages.push("SHACL validation failed");
+        return messages;
+    },
+};
+const analyzer = {
+    name: "analyzer",
+    run: async (file) => {
+        const findings = await analyze(JSON.parse(readFileSync(file, "utf8")), pathToFileURL(resolve(file)).href);
+        return findings.map((f) => `${severityPrefix(f.severity)}${f.rule} ${f.node ?? "-"}: ${f.message}`);
+    },
+};
+const layout = {
+    name: "layout",
+    run: async (file) => {
+        try {
+            layoutDocument(JSON.parse(readFileSync(file, "utf8")));
+            return [];
+        }
+        catch (error) {
+            if (error instanceof LayoutInputError)
+                return error.errors;
+            throw error;
+        }
+    },
+};
+const exportXml = async (file) => (await layoutAndExport(JSON.parse(readFileSync(file, "utf8")), { documentUrl: pathToFileURL(resolve(file)).href })).xml;
+const exported = {
+    name: "export",
+    run: async (file) => {
+        try {
+            await exportXml(file);
+            return [];
+        }
+        catch (error) {
+            if (error instanceof ExportInputError)
+                return error.errors;
+            throw error;
+        }
+    },
+};
+const reports = new Map();
+const externalReport = (file) => {
+    const key = `${resolve(file)}\n${readFileSync(file, "utf8")}`;
+    let report = reports.get(key);
+    if (!report) {
+        report = exportXml(file).then(checkXml);
+        reports.set(key, report);
+    }
+    return report;
+};
+const external = (name) => ({
+    name,
+    run: async (file) => {
+        const result = (await externalReport(file)).checks[name];
+        return result.issues.map((issue) => `${severityPrefix(issue.severity)}${issue.rule ? `${issue.rule}: ` : ""}${issue.message}`);
+    },
+});
+export const CHECKS = [structural, schema, shacl, analyzer, layout, exported, external("xsd"), external("moddle"), external("lint")];
+const MODEL_LINE = /^Model:\s*(\S+)\s*$/m;
+const collectNames = (value, names) => {
+    if (Array.isArray(value))
+        value.forEach((item) => collectNames(item, names));
+    else if (value && typeof value === "object")
+        for (const [key, child] of Object.entries(value)) {
+            if (key === "name" && typeof child === "string")
+                names.add(child);
+            else
+                collectNames(child, names);
+        }
+};
+const modelNames = (modelFile) => {
+    const text = readFileSync(modelFile, "utf8");
+    const document = extname(modelFile) === ".bpmn" ? convert(text, { fileName: modelFile }).document : JSON.parse(text);
+    const names = new Set();
+    collectNames(document, names);
+    return [...names];
+};
+const normalize = (text) => text.replace(/\s+/g, " ").toLowerCase();
+const mentionsElements = {
+    name: "mentions-elements",
+    run: async (file) => {
+        const evalsDir = dirname(dirname(file));
+        const prompt = readFileSync(join(evalsDir, "prompts", `${basename(file, ".md")}.md`), "utf8");
+        const model = prompt.match(MODEL_LINE)?.[1];
+        if (!model)
+            return ["prompt has no Model line"];
+        const explanation = normalize(readFileSync(file, "utf8"));
+        return modelNames(resolve(dirname(evalsDir), model))
+            .filter((name) => !explanation.includes(normalize(name)))
+            .map((name) => `does not mention "${name}"`);
+    },
+};
+export const EXPLANATION_CHECKS = [mentionsElements];
+const ALLOWED_LINE = /^Allowed-changes:[ \t]*(.*)$/m;
+const DI_TYPES = new Set(["BPMNDiagram", "BPMNPlane", "BPMNShape", "BPMNEdge", "BPMNLabel", "Bounds", "Point"]);
+const loadDocument = (modelFile) => {
+    const text = readFileSync(modelFile, "utf8");
+    return extname(modelFile) === ".bpmn" ? convert(text, { fileName: modelFile }).document : JSON.parse(text);
+};
+const isNode = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const isDi = (node) => DI_TYPES.has(String(node.type));
+const indexNodes = (value, elements, di) => {
+    if (Array.isArray(value))
+        value.forEach((item) => indexNodes(item, elements, di));
+    else if (isNode(value)) {
+        if (typeof value.id === "string")
+            (isDi(value) ? di : elements).set(value.id, value);
+        for (const [key, child] of Object.entries(value))
+            if (key !== "@context")
+                indexNodes(child, elements, di);
+    }
+};
+const ownProperties = (node) => {
+    const strip = (value) => {
+        if (Array.isArray(value))
+            return value.map(strip).filter((item) => item !== undefined);
+        if (isNode(value))
+            return typeof value.id === "string" ? undefined : Object.fromEntries(Object.entries(value).map(([k, v]) => [k, strip(v)]));
+        return value;
+    };
+    return JSON.stringify(Object.fromEntries(Object.entries(node).filter(([key]) => key !== "id").map(([key, value]) => [key, strip(value)]).sort(([a], [b]) => a.localeCompare(b))));
+};
+const modificationContext = (file) => {
+    const evalsDir = dirname(dirname(file));
+    const prompt = readFileSync(join(evalsDir, "prompts", `${basename(file, ".jsonld")}.md`), "utf8");
+    const model = prompt.match(MODEL_LINE)?.[1];
+    if (!model)
+        throw new Error("prompt has no Model line");
+    const allowedText = prompt.match(ALLOWED_LINE)?.[1];
+    if (allowedText === undefined)
+        throw new Error("prompt has no Allowed-changes line");
+    const allowed = new Set(allowedText.split(",").map((id) => id.trim()).filter(Boolean));
+    const before = { elements: new Map(), di: new Map() };
+    const after = { elements: new Map(), di: new Map() };
+    indexNodes(loadDocument(resolve(dirname(evalsDir), model)), before.elements, before.di);
+    indexNodes(JSON.parse(readFileSync(file, "utf8")), after.elements, after.di);
+    return { allowed, before, after };
+};
+const unchangedElements = {
+    name: "unchanged-elements",
+    run: async (file) => {
+        const { allowed, before, after } = modificationContext(file);
+        const failures = [];
+        for (const [id, node] of before.elements) {
+            if (allowed.has(id))
+                continue;
+            const next = after.elements.get(id);
+            if (!next)
+                failures.push(`element "${id}" was removed`);
+            else if (ownProperties(node) !== ownProperties(next))
+                failures.push(`element "${id}" changed`);
+        }
+        for (const id of after.elements.keys())
+            if (!before.elements.has(id) && !allowed.has(id))
+                failures.push(`element "${id}" was added`);
+        return failures;
+    },
+};
+const unchangedDi = {
+    name: "unchanged-di",
+    run: async (file) => {
+        const { allowed, before, after } = modificationContext(file);
+        const failures = [];
+        for (const [id, node] of before.di) {
+            if (node.type !== "BPMNShape" && node.type !== "BPMNEdge")
+                continue;
+            const next = after.di.get(id);
+            const element = String(node.bpmnElement);
+            if (!next) {
+                if (!allowed.has(element))
+                    failures.push(`diagram element "${id}" was removed`);
+                continue;
+            }
+            const key = node.type === "BPMNShape" ? "bounds" : "waypoints";
+            if (JSON.stringify(node[key]) !== JSON.stringify(next[key]))
+                failures.push(`diagram element "${id}" changed its ${key}`);
+        }
+        return failures;
+    },
+};
+export const MODIFICATION_CHECKS = [unchangedElements, unchangedDi];
+const loadExpected = (file) => {
+    const expectFile = join(dirname(file), `${basename(file, extname(file))}.expect.json`);
+    return existsSync(expectFile) ? JSON.parse(readFileSync(expectFile, "utf8")) : {};
+};
+export const evaluateFile = async (file, checks = CHECKS) => {
+    const failures = [];
+    const expected = loadExpected(file);
+    for (const [name, messages] of Object.entries(expected))
+        for (const message of messages)
+            if (!message.startsWith(WARNING_PREFIX))
+                failures.push({ check: name, message: `error findings cannot be recorded as expected: ${message}` });
+    for (const check of checks) {
+        try {
+            const remaining = [...(expected[check.name] ?? [])];
+            for (const message of await check.run(file)) {
+                const index = remaining.indexOf(message);
+                if (index >= 0)
+                    remaining.splice(index, 1);
+                else
+                    failures.push({ check: check.name, message });
+            }
+            for (const message of remaining)
+                failures.push({ check: check.name, message: `expected finding missing: ${message}` });
+        }
+        catch (error) {
+            failures.push({ check: check.name, message: error.message });
+        }
+    }
+    return { file, failures };
+};
+export const evaluateOutputs = async (dir, checks = CHECKS) => Promise.all(readdirSync(dir)
+    .filter((f) => f.endsWith(".jsonld"))
+    .sort()
+    .map((f) => evaluateFile(join(dir, f), checks)));
+export const evaluateExplanations = async (dir, checks = EXPLANATION_CHECKS) => Promise.all(readdirSync(dir)
+    .filter((f) => f.startsWith("explain-") && f.endsWith(".md"))
+    .sort()
+    .map((f) => evaluateFile(join(dir, f), checks)));
+export const evaluateModifications = async (dir, checks = MODIFICATION_CHECKS) => Promise.all(readdirSync(dir)
+    .filter((f) => (f.startsWith("modify-") || f.startsWith("refine-")) && f.endsWith(".jsonld"))
+    .sort()
+    .map((f) => evaluateFile(join(dir, f), checks)));

package/dist/eval/regenerate.d.ts

@@ -0,0 +1,10 @@
+export declare const EXPLAIN_PREFIX = "explain-";
+export declare const outputExtension: (name: string) => string;
+export type Generator = (prompt: string) => Promise<string>;
+export interface RegenerationEntry {
+    name: string;
+    status: "unchanged" | "changed" | "new";
+    diff: string;
+}
+export declare const lineDiff: (before: string, after: string) => string;
+export declare const regenerate: (dir: string, generate: Generator) => Promise<RegenerationEntry[]>;

package/dist/eval/regenerate.js

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export const EXPLAIN_PREFIX = "explain-";
+export const outputExtension = (name) => (name.startsWith(EXPLAIN_PREFIX) ? ".md" : ".jsonld");
+export const lineDiff = (before, after) => {
+    const a = before.split("\n");
+    const b = after.split("\n");
+    const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--)
+        for (let j = b.length - 1; j >= 0; j--)
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+    const lines = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i] === b[j])
+            (i++, j++);
+        else if (lcs[i + 1][j] >= lcs[i][j + 1])
+            lines.push(`-${a[i++]}`);
+        else
+            lines.push(`+${b[j++]}`);
+    }
+    while (i < a.length)
+        lines.push(`-${a[i++]}`);
+    while (j < b.length)
+        lines.push(`+${b[j++]}`);
+    return lines.join("\n");
+};
+export const regenerate = async (dir, generate) => {
+    const outputs = join(dir, "outputs");
+    mkdirSync(outputs, { recursive: true });
+    const report = [];
+    for (const file of readdirSync(join(dir, "prompts")).filter((f) => f.endsWith(".md")).sort()) {
+        const name = file.replace(/\.md$/, "");
+        const target = join(outputs, `${name}${outputExtension(name)}`);
+        const generated = await generate(readFileSync(join(dir, "prompts", file), "utf8"));
+        const existed = existsSync(target);
+        const previous = existed ? readFileSync(target, "utf8") : "";
+        writeFileSync(target, generated);
+        if (!existed)
+            report.push({ name, status: "new", diff: lineDiff("", generated) });
+        else if (previous === generated)
+            report.push({ name, status: "unchanged", diff: "" });
+        else
+            report.push({ name, status: "changed", diff: lineDiff(previous, generated) });
+    }
+    return report;
+};

package/dist/eval-regenerate-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/eval-regenerate-cli.js

@@ -0,0 +1,16 @@
+import { spawnSync } from "node:child_process";
+import { regenerate } from "./eval/regenerate.js";
+import { ROOT } from "./paths.js";
+const dir = process.argv[2] ?? `${ROOT}skills/bpmn-ld/evals`;
+const command = process.env.BPMN_LD_EVAL_GENERATOR ?? "claude -p";
+const generate = async (prompt) => {
+    const run = spawnSync(command, { input: prompt, encoding: "utf8", shell: true, maxBuffer: 64 * 1024 * 1024 });
+    if (run.status !== 0)
+        throw new Error(`generator "${command}" failed: ${run.stderr}`);
+    return run.stdout;
+};
+for (const entry of await regenerate(dir, generate)) {
+    console.log(`${entry.status.padEnd(9)}${entry.name}`);
+    if (entry.diff)
+        console.log(entry.diff);
+}

package/dist/export/data.d.ts

@@ -0,0 +1,10 @@
+import { type ElementMapping } from "../convert/mapping.ts";
+export declare const DATA_MAPPINGS: Record<string, ElementMapping>;
+export declare const EXPRESSION_ELEMENTS: string[];
+export declare const MAPPINGS: Record<string, ElementMapping>;
+export declare const THROW_EVENTS: string[];
+export declare const CATCH_EVENTS: string[];
+export declare const CONTAINS: Record<string, Record<string, string>>;
+export declare const EVENT_DEFINITION_ROOTS: Record<string, string>;
+export declare const DATA_ROOT_ELEMENTS: Record<string, string>;
+export declare const childRank: (key: string) => number;

package/dist/export/data.js

@@ -0,0 +1,127 @@
+import { CONTAINMENT, ELEMENT_MAPPINGS } from "../convert/mapping.js";
+const named = { id: "id", name: "name" };
+const flowDataElements = ["dataObject", "dataObjectReference", "dataStoreReference"];
+export const DATA_MAPPINGS = {
+    dataObject: { type: "DataObject", attributes: { ...named, isCollection: "isCollection" } },
+    dataObjectReference: { type: "DataObjectReference", attributes: { ...named, dataObjectRef: "dataObjectRef" } },
+    dataStore: {
+        type: "DataStore",
+        attributes: { ...named, capacity: "capacity", isUnlimited: "isUnlimited" },
+    },
+    dataStoreReference: { type: "DataStoreReference", attributes: { ...named, dataStoreRef: "dataStoreRef" } },
+};
+const CONTAINER_ACTIVITIES = ["subProcess", "adHocSubProcess", "transaction"];
+const ACTIVITIES = ["task", "businessRuleTask", "manualTask", "receiveTask", "sendTask", "scriptTask", "serviceTask", "userTask", ...CONTAINER_ACTIVITIES];
+const withIoSpecification = Object.fromEntries(ACTIVITIES.map((name) => [
+    name,
+    { ...ELEMENT_MAPPINGS[name], singles: { ...ELEMENT_MAPPINGS[name].singles, ioSpecification: "ioSpecification" } },
+]));
+const dataItem = { ...named, isCollection: "isCollection" };
+const SET_MAPPINGS = {
+    ioSpecification: { type: "InputOutputSpecification", attributes: { id: "id" } },
+    dataInput: { type: "DataInput", attributes: dataItem },
+    dataOutput: { type: "DataOutput", attributes: dataItem },
+    inputSet: {
+        type: "InputSet",
+        attributes: { id: "id" },
+        textLists: {
+            dataInputRefs: "dataInputRefs",
+            optionalInputRefs: "optionalInputRefs",
+            whileExecutingInputRefs: "whileExecutingInputRefs",
+            outputSetRefs: "outputSetRefs",
+        },
+    },
+    outputSet: {
+        type: "OutputSet",
+        attributes: { id: "id" },
+        textLists: {
+            dataOutputRefs: "dataOutputRefs",
+            optionalOutputRefs: "optionalOutputRefs",
+            whileExecutingOutputRefs: "whileExecutingOutputRefs",
+            inputSetRefs: "inputSetRefs",
+        },
+    },
+};
+const expression = () => ({
+    type: "FormalExpression",
+    attributes: { language: "language", evaluatesToTypeRef: "evaluatesToTypeRef" },
+    bodyTerm: "body",
+    anonymous: true,
+});
+const association = (type) => ({
+    type,
+    attributes: { id: "id" },
+    textLists: { sourceRef: "sourceRef" },
+    textChildren: { targetRef: "targetRef" },
+    singles: { transformation: "transformation" },
+});
+const ASSOCIATION_MAPPINGS = {
+    dataInputAssociation: association("DataInputAssociation"),
+    dataOutputAssociation: association("DataOutputAssociation"),
+    assignment: { type: "Assignment", attributes: { id: "id" }, singles: { from: "from", to: "to" } },
+    transformation: expression(),
+    from: expression(),
+    to: expression(),
+};
+const CONDITION_ELEMENTS = ["completionCondition", "condition", "activationCondition"];
+export const EXPRESSION_ELEMENTS = ["conditionExpression", ...CONDITION_ELEMENTS, "transformation", "from", "to"];
+export const MAPPINGS = {
+    ...ELEMENT_MAPPINGS,
+    ...withIoSpecification,
+    ...DATA_MAPPINGS,
+    ...SET_MAPPINGS,
+    ...ASSOCIATION_MAPPINGS,
+};
+const flowData = Object.fromEntries(flowDataElements.map((name) => [name, "flowElements"]));
+const associations = { dataInputAssociation: "dataInputAssociations", dataOutputAssociation: "dataOutputAssociations" };
+const throwData = { dataInput: "dataInputs", dataInputAssociation: "dataInputAssociations", inputSet: "inputSets" };
+const catchData = { dataOutput: "dataOutputs", dataOutputAssociation: "dataOutputAssociations", outputSet: "outputSets" };
+export const THROW_EVENTS = ["intermediateThrowEvent", "implicitThrowEvent", "endEvent"];
+export const CATCH_EVENTS = ["startEvent", "intermediateCatchEvent", "boundaryEvent"];
+const dataContainment = {
+    process: flowData,
+    ...Object.fromEntries(CONTAINER_ACTIVITIES.map((name) => [name, { ...flowData, ...associations }])),
+    ...Object.fromEntries(ACTIVITIES.filter((name) => !CONTAINER_ACTIVITIES.includes(name)).map((name) => [name, associations])),
+    ...Object.fromEntries(THROW_EVENTS.map((name) => [name, throwData])),
+    ...Object.fromEntries(CATCH_EVENTS.map((name) => [name, catchData])),
+    assignment: {},
+    dataInputAssociation: { assignment: "assignments" },
+    dataOutputAssociation: { assignment: "assignments" },
+    ioSpecification: { dataInput: "dataInputs", dataOutput: "dataOutputs", inputSet: "inputSets", outputSet: "outputSets" },
+};
+export const CONTAINS = Object.fromEntries([...new Set([...Object.keys(CONTAINMENT), ...Object.keys(dataContainment)])].map((name) => [
+    name,
+    { ...CONTAINMENT[name], ...dataContainment[name] },
+]));
+export const EVENT_DEFINITION_ROOTS = Object.fromEntries(Object.keys(CONTAINMENT.startEvent).map((name) => [ELEMENT_MAPPINGS[name].type, name]));
+export const DATA_ROOT_ELEMENTS = { DataStore: "dataStore" };
+const DATA_CHILD_ORDER = [
+    "incoming",
+    "outgoing",
+    "ioSpecification",
+    "dataInput",
+    "dataOutput",
+    "dataInputAssociation",
+    "dataOutputAssociation",
+    "inputSet",
+    "outputSet",
+    "partitionElement",
+    "source",
+    "target",
+    "sourceRef",
+    "targetRef",
+    "transformation",
+    "assignment",
+];
+export const childRank = (key) => {
+    if (key.startsWith("@_"))
+        return -1;
+    if (key === "extensionElements")
+        return -0.5;
+    if (key === "eventDefinitionRef")
+        return DATA_CHILD_ORDER.length + 0.5;
+    if (CONDITION_ELEMENTS.includes(key))
+        return DATA_CHILD_ORDER.length + 1;
+    const index = DATA_CHILD_ORDER.indexOf(key);
+    return index === -1 ? DATA_CHILD_ORDER.length : index;
+};

package/dist/export/diagram.d.ts

@@ -0,0 +1,8 @@
+import type { Extensions } from "./extensions.ts";
+import { type ExportWarning, type Json, type XmlNode } from "./element.ts";
+export declare const DIAGRAM_NAMESPACES: Record<string, string>;
+export declare const DIAGRAM_EXPORT: Record<string, {
+    attributes: string[];
+    children: string[];
+}>;
+export declare const exportDiagram: (node: Json, location: string, warnings: ExportWarning[], extensions: Extensions) => XmlNode;

package/dist/export/diagram.js

@@ -0,0 +1,112 @@
+import { DC_NAMESPACE, DD_NAMESPACE, DI_NAMESPACE } from "../convert/mapping.js";
+import { isObject, unsupported } from "./element.js";
+export const DIAGRAM_NAMESPACES = {
+    "@_xmlns:bpmndi": DI_NAMESPACE,
+    "@_xmlns:dc": DC_NAMESPACE,
+    "@_xmlns:di": DD_NAMESPACE,
+};
+export const DIAGRAM_EXPORT = {
+    BPMNDiagram: { attributes: ["id", "name", "resolution"], children: ["plane"] },
+    BPMNPlane: { attributes: ["id", "bpmnElement"], children: ["planeElements"] },
+    BPMNShape: {
+        attributes: ["id", "bpmnElement", "isExpanded", "isHorizontal", "isMarkerVisible", "isMessageVisible"],
+        children: ["bounds", "label"],
+    },
+    BPMNEdge: { attributes: ["id", "bpmnElement", "sourceElement", "targetElement", "messageVisibleKind"], children: ["waypoints", "label"] },
+    BPMNLabel: { attributes: [], children: ["bounds"] },
+    Bounds: { attributes: ["x", "y", "width", "height"], children: [] },
+    waypoint: { attributes: ["x", "y"], children: [] },
+};
+const text = (value) => String(value);
+const attributes = (node, names, handled) => {
+    const result = {};
+    for (const name of names) {
+        handled.add(name);
+        if (node[name] !== undefined)
+            result[`@_${name}`] = text(node[name]);
+    }
+    return result;
+};
+const report = (node, handled, element, location, warnings, extensions, foreign = true) => {
+    for (const key of Object.keys(node).sort()) {
+        if (!handled.has(key) && !(foreign && extensions.attribute(key, node[key], element)))
+            warnings.push(unsupported("unsupported-property", key, `${location}/${key}`, node));
+    }
+};
+const base = () => new Set(["type"]);
+const exportBounds = (node, location, warnings, extensions) => {
+    const handled = base();
+    const element = attributes(node, DIAGRAM_EXPORT.Bounds.attributes, handled);
+    report(node, handled, element, location, warnings, extensions, false);
+    return element;
+};
+const exportLabel = (node, location, warnings, extensions) => {
+    const handled = base();
+    const element = {};
+    handled.add("bounds");
+    if (isObject(node.bounds))
+        element["dc:Bounds"] = exportBounds(node.bounds, `${location}/bounds`, warnings, extensions);
+    report(node, handled, element, location, warnings, extensions);
+    return element;
+};
+const exportPoint = (node, location, warnings, extensions) => {
+    const handled = base();
+    const element = attributes(node, DIAGRAM_EXPORT.waypoint.attributes, handled);
+    report(node, handled, element, location, warnings, extensions, false);
+    return element;
+};
+const exportShape = (node, location, warnings, extensions) => {
+    const handled = base();
+    handled.add("id");
+    const element = attributes(node, DIAGRAM_EXPORT.BPMNShape.attributes, handled);
+    handled.add("bounds");
+    handled.add("label");
+    if (isObject(node.bounds))
+        element["dc:Bounds"] = exportBounds(node.bounds, `${location}/bounds`, warnings, extensions);
+    if (isObject(node.label))
+        element["bpmndi:BPMNLabel"] = exportLabel(node.label, `${location}/label`, warnings, extensions);
+    report(node, handled, element, location, warnings, extensions);
+    return element;
+};
+const exportEdge = (node, location, warnings, extensions) => {
+    const handled = base();
+    const element = attributes(node, DIAGRAM_EXPORT.BPMNEdge.attributes, handled);
+    handled.add("waypoints");
+    handled.add("label");
+    if (Array.isArray(node.waypoints)) {
+        element["di:waypoint"] = node.waypoints.map((waypoint, index) => exportPoint(waypoint, `${location}/waypoints/${index}`, warnings, extensions));
+    }
+    if (isObject(node.label))
+        element["bpmndi:BPMNLabel"] = exportLabel(node.label, `${location}/label`, warnings, extensions);
+    report(node, handled, element, location, warnings, extensions);
+    return element;
+};
+const exportPlane = (node, location, warnings, extensions) => {
+    const handled = base();
+    const element = attributes(node, DIAGRAM_EXPORT.BPMNPlane.attributes, handled);
+    handled.add("planeElements");
+    const members = Array.isArray(node.planeElements) ? node.planeElements : [];
+    const children = [];
+    members.forEach((member, index) => {
+        const memberLocation = `${location}/planeElements/${index}`;
+        if (member.type === "BPMNShape")
+            children.push({ "bpmndi:BPMNShape": exportShape(member, memberLocation, warnings, extensions) });
+        else if (member.type === "BPMNEdge")
+            children.push({ "bpmndi:BPMNEdge": exportEdge(member, memberLocation, warnings, extensions) });
+        else
+            warnings.push(unsupported("unsupported-element", String(member.type), memberLocation, member));
+    });
+    if (children.length > 0)
+        element["#children"] = children;
+    report(node, handled, element, location, warnings, extensions);
+    return element;
+};
+export const exportDiagram = (node, location, warnings, extensions) => {
+    const handled = base();
+    const element = attributes(node, DIAGRAM_EXPORT.BPMNDiagram.attributes, handled);
+    handled.add("plane");
+    if (isObject(node.plane))
+        element["bpmndi:BPMNPlane"] = exportPlane(node.plane, `${location}/plane`, warnings, extensions);
+    report(node, handled, element, location, warnings, extensions, false);
+    return element;
+};

package/dist/export/element.d.ts

@@ -0,0 +1,27 @@
+import type { Extensions } from "./extensions.ts";
+export interface ExportWarning {
+    kind: "unsupported";
+    code: WarningCode;
+    construct: string;
+    location: string;
+    node?: string;
+    message?: string;
+}
+export type WarningCode = "unsupported-root" | "unsupported-element" | "unsupported-property";
+export type Json = Record<string, any>;
+export type XmlNode = Record<string, any>;
+export declare const isObject: (value: unknown) => value is Json;
+export declare const unsupported: (code: WarningCode, construct: string, location: string, owner?: Json) => ExportWarning;
+export declare const SUPPORTED_ELEMENTS: Record<string, string[]>;
+export declare const elementName: (type: unknown) => string | undefined;
+export declare class ExportContext {
+    readonly warnings: ExportWarning[];
+    readonly roots: Record<string, XmlNode[]>;
+    private readonly usedIds;
+    private readonly references;
+    readonly extensions: Extensions;
+    constructor(usedIds: Set<string>, extensions: Extensions);
+    reference(root: string, attribute: string, value: string): string;
+}
+export declare const collectIds: (value: unknown, ids?: Set<string>) => Set<string>;
+export declare const exportElement: (name: string, node: Json, location: string, context: ExportContext) => XmlNode;