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

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;

package/dist/export/element.js

@@ -0,0 +1,175 @@
+import { CONTAINMENT } from "../convert/mapping.js";
+import { CATCH_EVENTS, childRank, CONTAINS, EXPRESSION_ELEMENTS, MAPPINGS, THROW_EVENTS } from "./data.js";
+export const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const unsupported = (code, construct, location, owner) => ({
+    kind: "unsupported",
+    code,
+    construct,
+    location,
+    ...(typeof owner?.id === "string" ? { node: owner.id } : {}),
+});
+const SUB_PROCESSES = ["subProcess", "adHocSubProcess", "transaction"];
+const EXCLUDED_FLOW_ELEMENTS = [...SUB_PROCESSES, "laneSet"];
+const PROPERTY_ORDER = ["laneSets"];
+const FLOW_ELEMENTS = Object.keys(CONTAINS.process).filter((name) => !EXCLUDED_FLOW_ELEMENTS.includes(name));
+const EVENT_DEFINITIONS = Object.keys(CONTAINMENT.startEvent);
+const EVENTS = ["startEvent", "endEvent", "intermediateCatchEvent", "intermediateThrowEvent", "boundaryEvent"];
+const ASSOCIATIONS = ["dataInputAssociation", "dataOutputAssociation"];
+const NON_FLOW_NODES = ["sequenceFlow", "association", "laneSet", "dataObject", "dataObjectReference", "dataStoreReference"];
+const FLOW_NODES = [...FLOW_ELEMENTS, ...SUB_PROCESSES].filter((name) => !NON_FLOW_NODES.includes(name));
+const CONTAINER_ELEMENTS = [...FLOW_ELEMENTS, ...SUB_PROCESSES, "laneSet"];
+const ACTIVITY_ELEMENTS = ["task", "businessRuleTask", "manualTask", "receiveTask", "sendTask", "scriptTask", "serviceTask", "userTask"];
+export const SUPPORTED_ELEMENTS = {
+    process: CONTAINER_ELEMENTS,
+    ...Object.fromEntries(SUB_PROCESSES.map((name) => [name, [...CONTAINER_ELEMENTS, ...ASSOCIATIONS]])),
+    ...Object.fromEntries(ACTIVITY_ELEMENTS.map((name) => [name, ASSOCIATIONS])),
+    dataInputAssociation: ["assignment"],
+    dataOutputAssociation: ["assignment"],
+    ioSpecification: ["dataInput", "dataOutput", "inputSet", "outputSet"],
+    laneSet: ["lane"],
+    childLaneSet: ["lane"],
+    collaboration: ["participant", "messageFlow"],
+    ...Object.fromEntries(EVENTS.map((name) => [name, EVENT_DEFINITIONS])),
+    ...Object.fromEntries(THROW_EVENTS.map((name) => [name, [...EVENT_DEFINITIONS, "dataInput", "dataInputAssociation", "inputSet"]])),
+    ...Object.fromEntries(CATCH_EVENTS.map((name) => [name, [...EVENT_DEFINITIONS, "dataOutput", "dataOutputAssociation", "outputSet"]])),
+};
+export const elementName = (type) => {
+    if (typeof type !== "string" || type === "")
+        return undefined;
+    const name = type[0].toLowerCase() + type.slice(1);
+    return MAPPINGS[name]?.type === type ? name : undefined;
+};
+export class ExportContext {
+    warnings = [];
+    roots = {};
+    usedIds;
+    references = new Map();
+    extensions;
+    constructor(usedIds, extensions) {
+        this.usedIds = usedIds;
+        this.extensions = extensions;
+    }
+    reference(root, attribute, value) {
+        const key = `${root}\u0000${value}`;
+        const known = this.references.get(key);
+        if (known !== undefined)
+            return known;
+        let index = this.references.size + 1;
+        let id = `${root[0].toUpperCase()}${root.slice(1)}_${index}`;
+        while (this.usedIds.has(id))
+            id = `${root[0].toUpperCase()}${root.slice(1)}_${++index}`;
+        this.usedIds.add(id);
+        this.references.set(key, id);
+        (this.roots[root] ??= []).push({ "@_id": id, [`@_${attribute}`]: value });
+        return id;
+    }
+}
+export const collectIds = (value, ids = new Set()) => {
+    if (Array.isArray(value))
+        value.forEach((item) => collectIds(item, ids));
+    else if (isObject(value)) {
+        if (typeof value.id === "string")
+            ids.add(value.id);
+        Object.values(value).forEach((item) => collectIds(item, ids));
+    }
+    return ids;
+};
+const connectionsOf = (members) => {
+    const connections = new Map();
+    const entry = (id) => connections.get(id) ?? connections.set(id, { incoming: [], outgoing: [] }).get(id);
+    for (const member of Array.isArray(members) ? members : []) {
+        if (!isObject(member) || member.type !== "SequenceFlow" || typeof member.id !== "string")
+            continue;
+        if (typeof member.sourceRef === "string")
+            entry(member.sourceRef).outgoing.push(member.id);
+        if (typeof member.targetRef === "string")
+            entry(member.targetRef).incoming.push(member.id);
+    }
+    return connections;
+};
+const ordered = (element) => Object.fromEntries(Object.entries(element).sort(([a], [b]) => childRank(a) - childRank(b)));
+const toText = (value) => String(value);
+const exportPartitionElement = (node, location, parent, context) => {
+    const name = elementName(node.type);
+    if (name === undefined) {
+        context.warnings.push(unsupported("unsupported-element", String(node.type), location, node));
+        return;
+    }
+    parent.partitionElement = { ...exportElement(name, node, location, context), "@_xsi:type": `t${node.type}` };
+};
+export const exportElement = (name, node, location, context) => {
+    const mapping = MAPPINGS[name];
+    const element = {};
+    const handled = new Set(["id", "type", "@context"]);
+    for (const [attribute, term] of Object.entries(mapping.attributes)) {
+        handled.add(term);
+        if (node[term] !== undefined)
+            element[`@_${attribute}`] = (mapping.hashPrefixed?.includes(term) ? "##" : "") + toText(node[term]);
+    }
+    for (const lookup of mapping.lookups ?? []) {
+        handled.add(lookup.term);
+        if (node[lookup.term] !== undefined && element[`@_${lookup.attribute}`] === undefined) {
+            element[`@_${lookup.attribute}`] = context.reference(lookup.root, lookup.from, toText(node[lookup.term]));
+        }
+    }
+    for (const [child, term] of Object.entries(mapping.textChildren ?? {})) {
+        handled.add(term);
+        if (node[term] !== undefined)
+            element[child] = toText(node[term]);
+    }
+    for (const [child, term] of Object.entries(mapping.textLists ?? {})) {
+        handled.add(term);
+        if (Array.isArray(node[term]))
+            element[child] = node[term].map(toText);
+        else if (node[term] !== undefined)
+            element[child] = [toText(node[term])];
+    }
+    if (mapping.bodyTerm !== undefined) {
+        handled.add(mapping.bodyTerm);
+        if (node[mapping.bodyTerm] !== undefined)
+            element["#text"] = toText(node[mapping.bodyTerm]);
+    }
+    if (EXPRESSION_ELEMENTS.includes(name)) {
+        element["@_xsi:type"] = "tFormalExpression";
+    }
+    if (name === "conditionalEventDefinition" && !isObject(node.condition))
+        element.condition = { "@_xsi:type": "tFormalExpression" };
+    for (const [child, term] of Object.entries(mapping.singles ?? {})) {
+        handled.add(term);
+        if (!isObject(node[term]))
+            continue;
+        if (child === "partitionElement")
+            exportPartitionElement(node[term], `${location}/${term}`, element, context);
+        else
+            element[child] = exportElement(child, node[term], `${location}/${term}`, context);
+    }
+    const connections = name === "process" || SUB_PROCESSES.includes(name) ? connectionsOf(node.flowElements) : new Map();
+    const allowed = SUPPORTED_ELEMENTS[name] ?? [];
+    const properties = [...new Set(Object.values(CONTAINS[name] ?? {}))].sort((a, b) => Number(!PROPERTY_ORDER.includes(a)) - Number(!PROPERTY_ORDER.includes(b)));
+    for (const property of properties) {
+        handled.add(property);
+        const members = Array.isArray(node[property]) ? node[property] : [];
+        members.forEach((member, index) => {
+            const memberLocation = `${location}/${property}/${index}`;
+            const memberName = elementName(member.type);
+            if (memberName === undefined || !allowed.includes(memberName) || CONTAINS[name][memberName] !== property) {
+                context.warnings.push(unsupported("unsupported-element", String(member.type), memberLocation, member));
+                return;
+            }
+            let exported = exportElement(memberName, member, memberLocation, context);
+            const linked = FLOW_NODES.includes(memberName) && typeof member.id === "string" ? connections.get(member.id) : undefined;
+            if (linked?.incoming.length)
+                exported.incoming = linked.incoming;
+            if (linked?.outgoing.length)
+                exported.outgoing = linked.outgoing;
+            if (linked)
+                exported = ordered(exported);
+            (element[memberName] ??= []).push(exported);
+        });
+    }
+    for (const key of Object.keys(node).sort()) {
+        if (!handled.has(key) && !context.extensions.apply(key, node[key], element))
+            context.warnings.push(unsupported("unsupported-property", key, `${location}/${key}`, node));
+    }
+    return ordered(element);
+};

package/dist/export/export.d.ts

@@ -0,0 +1,22 @@
+import { type ExportWarning } from "./element.ts";
+export type { ExportWarning };
+export interface ExportResult {
+    xml: string;
+    warnings: ExportWarning[];
+}
+export interface ExportOptions {
+    documentUrl?: string;
+}
+export interface ExportError {
+    code: "not-an-object" | "invalid-context" | "invalid-document" | "unreadable-input" | "invalid-json" | "cannot-write" | "strict-mode";
+    location: string;
+    message: string;
+}
+export declare class ExportInputError extends Error {
+    readonly findings: ExportError[];
+    readonly errors: string[];
+    constructor(findings: ExportError[]);
+}
+export declare const schemaFinding: (message: string) => ExportError;
+export declare const ROOT_ELEMENTS: Record<string, string>;
+export declare const exportDocument: (input: unknown, options?: ExportOptions) => Promise<ExportResult>;

package/dist/export/export.js

@@ -0,0 +1,124 @@
+import { XMLBuilder } from "fast-xml-parser";
+import { compileSchema, validateWithSchema } from "../schema-validate.js";
+import { defaultBase } from "../convert/convert.js";
+import { MODEL_NAMESPACE, XSI_NAMESPACE } from "../convert/mapping.js";
+import { DATA_ROOT_ELEMENTS, EVENT_DEFINITION_ROOTS } from "./data.js";
+import { Extensions } from "./extensions.js";
+import { normalize } from "./normalize.js";
+import { DIAGRAM_NAMESPACES, exportDiagram } from "./diagram.js";
+import { collectIds, exportElement, ExportContext, isObject, unsupported } from "./element.js";
+const describe = (error) => `${error.location} ${error.message}`;
+export class ExportInputError extends Error {
+    findings;
+    errors;
+    constructor(findings) {
+        const errors = findings.map(describe);
+        super(`invalid BPMN-LD document: ${errors[0]}`);
+        this.name = "ExportInputError";
+        this.findings = findings;
+        this.errors = errors;
+    }
+}
+export const schemaFinding = (message) => {
+    const split = message.indexOf(" ");
+    return { code: "invalid-document", location: message.slice(0, split), message: message.slice(split + 1) };
+};
+const absolute = (id, base) => {
+    try {
+        return new URL(id, base).href;
+    }
+    catch {
+        return id;
+    }
+};
+export const ROOT_ELEMENTS = { Process: "process", Collaboration: "collaboration", Message: "message", Signal: "signal", Error: "error", Escalation: "escalation", ...EVENT_DEFINITION_ROOTS, ...DATA_ROOT_ELEMENTS };
+const ESCAPES = [
+    [/\r/g, "\uE00D", "
"],
+    [/\n/g, "\uE00A", "
"],
+    [/\t/g, "\uE009", "	"],
+];
+const protect = (value, attribute) => ESCAPES.slice(0, attribute ? 3 : 1).reduce((text, [pattern, sentinel]) => text.replace(pattern, sentinel), value);
+const restore = (xml) => ESCAPES.reduce((text, [, sentinel, entity]) => text.replaceAll(sentinel, entity), xml);
+const toOrdered = (tag, value) => {
+    if (!isObject(value))
+        return [{ [tag]: [{ "#text": protect(String(value), false) }] }];
+    const attributes = {};
+    const children = [];
+    for (const [key, member] of Object.entries(value)) {
+        if (key.startsWith("@_"))
+            attributes[key] = protect(String(member), true);
+        else if (key === "#text")
+            children.push({ "#text": protect(String(member), false) });
+        else if (key === "#children") {
+            for (const child of member) {
+                const [[childTag, childValue]] = Object.entries(child);
+                children.push(...toOrdered(childTag, childValue));
+            }
+        }
+        else if (Array.isArray(member))
+            member.forEach((item) => children.push(...toOrdered(key, item)));
+        else
+            children.push(...toOrdered(key, member));
+    }
+    return [Object.keys(attributes).length > 0 ? { [tag]: children, ":@": attributes } : { [tag]: children }];
+};
+let compiled;
+const schema = () => (compiled ??= compileSchema());
+const unique = (errors) => [...new Set(errors)];
+const targetNamespace = (document) => {
+    const context = Array.isArray(document["@context"]) ? document["@context"] : [document["@context"]];
+    const base = context.find((entry) => isObject(entry) && typeof entry["@base"] === "string");
+    return base?.["@base"] ?? defaultBase();
+};
+export const exportDocument = async (input, options = {}) => {
+    if (!isObject(input))
+        throw new ExportInputError([{ code: "not-an-object", location: "/", message: "document must be a JSON object" }]);
+    let document;
+    try {
+        document = await normalize(input, options.documentUrl);
+    }
+    catch (error) {
+        throw new ExportInputError([{ code: "invalid-context", location: "/@context", message: error.message }]);
+    }
+    const errors = unique(validateWithSchema(document, schema()));
+    if (errors.length > 0)
+        throw new ExportInputError(errors.map(schemaFinding));
+    const context = new ExportContext(collectIds(document), new Extensions(document["@context"], targetNamespace(document)));
+    const { warnings } = context;
+    const graph = Array.isArray(document["@graph"]) ? document["@graph"] : [document];
+    const prefix = Array.isArray(document["@graph"]) ? "/@graph" : "";
+    const definitions = {
+        "@_xmlns": MODEL_NAMESPACE,
+        "@_xmlns:xsi": XSI_NAMESPACE,
+        "@_id": "Definitions_1",
+        "@_targetNamespace": targetNamespace(document),
+    };
+    graph.forEach((root, index) => {
+        const location = prefix === "" ? "" : `${prefix}/${index}`;
+        if (root.type === "BPMNDiagram") {
+            (definitions["bpmndi:BPMNDiagram"] ??= []).push(exportDiagram(root, location, warnings, context.extensions));
+            return;
+        }
+        const name = ROOT_ELEMENTS[root.type];
+        if (name === undefined) {
+            warnings.push(unsupported("unsupported-root", root.type, location || "/", root));
+            return;
+        }
+        (definitions[name] ??= []).push(exportElement(name, root, location, context));
+    });
+    const { process: processes, collaboration: collaborations, "bpmndi:BPMNDiagram": diagrams, ...attributes } = definitions;
+    const generated = Object.fromEntries(Object.entries(context.roots).map(([name, nodes]) => [name, [...(attributes[name] ?? []), ...nodes]]));
+    const ordered = {
+        ...attributes,
+        ...Object.fromEntries([...context.extensions.namespaces].map(([prefix, namespace]) => [`@_xmlns:${prefix}`, namespace])),
+        ...(diagrams ? DIAGRAM_NAMESPACES : {}),
+        ...generated,
+        ...(collaborations ? { collaboration: collaborations } : {}),
+        ...(processes ? { process: processes } : {}),
+        ...(diagrams ? { "bpmndi:BPMNDiagram": diagrams } : {}),
+    };
+    const builder = new XMLBuilder({ preserveOrder: true, ignoreAttributes: false, attributeNamePrefix: "@_", attributesGroupName: ":@", format: true, suppressEmptyNode: true, suppressBooleanAttributes: false });
+    const base = targetNamespace(document);
+    const located = warnings.map((warning) => (warning.node === undefined ? warning : { ...warning, node: absolute(warning.node, base) }));
+    return { xml: `<?xml version="1.0" encoding="UTF-8"?>\n${restore(String(builder.build(toOrdered("definitions", ordered)))).trimStart()}`, warnings: located };
+};

package/dist/export/extensions.d.ts

@@ -0,0 +1,18 @@
+import { type XmlNode } from "./element.ts";
+export declare class Extensions {
+    readonly namespaces: Map<string, string>;
+    private readonly terms;
+    private readonly references;
+    private readonly base;
+    private readonly byNamespace;
+    private generated;
+    constructor(context: unknown, base: string);
+    private expand;
+    private prefixFor;
+    qualify(key: string): string | undefined;
+    private content;
+    private resolve;
+    private scalar;
+    attribute(key: string, value: unknown, element: XmlNode): boolean;
+    apply(key: string, value: unknown, element: XmlNode): boolean;
+}