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

package/dist/convert/extensions.js

@@ -0,0 +1,103 @@
+import { BPMN_NAMESPACES, MODEL_NAMESPACE, XSI_NAMESPACE } from "./mapping.js";
+import { loadContextTerms } from "./mapping-check.js";
+const ATTRIBUTE_NAMESPACE = /^\{(.*)\}(.*)$/;
+const ABSOLUTE_NAMESPACE = /^[A-Za-z][A-Za-z0-9+.-]*:/;
+const GENERAL_DELIMITER = /[:/?#[\]@]$/;
+const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+const RESERVED_PREFIXES = ["xml", "xmlns", "xsi"];
+const MIXED_CONTENT = "text content cannot be represented next to attributes or child elements";
+export const isExtensionNamespace = (namespace) => ABSOLUTE_NAMESPACE.test(namespace) && !BPMN_NAMESPACES.includes(namespace) && namespace !== XSI_NAMESPACE && namespace !== XML_NAMESPACE;
+const isIgnoredNamespace = (namespace) => namespace === XSI_NAMESPACE || namespace === XML_NAMESPACE;
+export const isExtensionAttribute = (key) => {
+    const match = ATTRIBUTE_NAMESPACE.exec(key);
+    return match !== null && isExtensionNamespace(match[1]);
+};
+const walkDeclarations = (element, visit) => {
+    element.declarations.forEach(([prefix, namespace]) => visit(prefix, namespace));
+    element.children.forEach((child) => walkDeclarations(child, visit));
+};
+export class Prefixes {
+    hints = new Map();
+    declared = new Set();
+    terms = new Set(Object.keys(loadContextTerms()));
+    byNamespace = new Map();
+    byPrefix = new Map();
+    generated = 0;
+    constructor(root) {
+        walkDeclarations(root, (prefix, namespace) => {
+            this.declared.add(prefix);
+            if (prefix !== "")
+                this.hints.set(namespace, [...(this.hints.get(namespace) ?? []), prefix]);
+        });
+    }
+    available(prefix) {
+        return !RESERVED_PREFIXES.includes(prefix) && !this.terms.has(prefix) && !this.byPrefix.has(prefix);
+    }
+    prefixFor(namespace) {
+        const known = this.byNamespace.get(namespace);
+        if (known !== undefined)
+            return known;
+        let prefix = (this.hints.get(namespace) ?? []).find((hint) => this.available(hint));
+        while (prefix === undefined) {
+            const candidate = `ns${++this.generated}`;
+            if (this.available(candidate) && !this.declared.has(candidate))
+                prefix = candidate;
+        }
+        this.byNamespace.set(namespace, prefix);
+        this.byPrefix.set(prefix, namespace);
+        return prefix;
+    }
+    context() {
+        return Object.fromEntries([...this.byPrefix].map(([prefix, namespace]) => [prefix, GENERAL_DELIMITER.test(namespace) ? namespace : { "@id": namespace, "@prefix": true }]));
+    }
+}
+const add = (target, name, value) => {
+    const existing = target[name];
+    target[name] = existing === undefined ? value : [...(Array.isArray(existing) ? existing : [existing]), value];
+};
+const addAttributes = (target, element, prefixes, unqualified) => {
+    for (const [key, value] of Object.entries(element.attributes)) {
+        const match = ATTRIBUTE_NAMESPACE.exec(key);
+        if (match) {
+            if (isExtensionNamespace(match[1]))
+                add(target, `${prefixes.prefixFor(match[1])}:${match[2]}`, value);
+        }
+        else if (unqualified)
+            add(target, `${prefixes.prefixFor(element.namespace)}:${key}`, value);
+    }
+};
+const addChildren = (target, element, prefixes) => {
+    for (const child of element.children) {
+        if (isExtensionNamespace(child.namespace))
+            add(target, `${prefixes.prefixFor(child.namespace)}:${child.name}`, valueOf(child, prefixes));
+    }
+};
+const valueOf = (element, prefixes) => {
+    const properties = {};
+    addAttributes(properties, element, prefixes, true);
+    addChildren(properties, element, prefixes);
+    return Object.keys(properties).length === 0 ? element.text : properties;
+};
+const containers = (element) => element.children.filter((child) => child.namespace === MODEL_NAMESPACE && child.name === "extensionElements");
+export const extensionProperties = (element, prefixes) => {
+    const properties = {};
+    addAttributes(properties, element, prefixes, false);
+    for (const container of containers(element))
+        addChildren(properties, container, prefixes);
+    return properties;
+};
+const rejected = (child) => ({ kind: "foreign-namespace", construct: child.name, location: child.location });
+const unrepresentable = (element) => {
+    const warnings = [];
+    const hasProperties = Object.keys(element.attributes).some((key) => !ATTRIBUTE_NAMESPACE.test(key) || isExtensionAttribute(key)) || element.children.some((child) => isExtensionNamespace(child.namespace));
+    if (hasProperties && element.text !== "")
+        warnings.push({ ...rejected(element), message: MIXED_CONTENT });
+    for (const key of Object.keys(element.attributes)) {
+        const match = ATTRIBUTE_NAMESPACE.exec(key);
+        if (match && !isExtensionNamespace(match[1]) && !isIgnoredNamespace(match[1])) {
+            warnings.push({ kind: "foreign-namespace", construct: `${element.name}@${match[2]}`, location: `${element.location}/@${match[2]}` });
+        }
+    }
+    return [...warnings, ...element.children.flatMap((child) => (isExtensionNamespace(child.namespace) ? unrepresentable(child) : [rejected(child)]))];
+};
+export const extensionWarnings = (container) => container.children.flatMap((child) => (isExtensionNamespace(child.namespace) ? unrepresentable(child) : [rejected(child)]));

package/dist/convert/mapping-check.d.ts

@@ -0,0 +1,15 @@
+import type { Store } from "n3";
+import type { ElementMapping } from "./mapping.ts";
+export interface MappingTables {
+    elements: Record<string, ElementMapping>;
+    containment: Record<string, Record<string, string>>;
+}
+export interface MappingProblem {
+    term: string;
+    kind: "class" | "property";
+    where: string;
+    reason: "not-in-context" | "not-in-ontology";
+}
+export declare const CONTEXT_FILES: string[];
+export declare const loadContextTerms: () => Record<string, string>;
+export declare const checkMapping: (tables: MappingTables, store: Store, context: Record<string, string>) => MappingProblem[];

package/dist/convert/mapping-check.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ROOT } from "../paths.js";
+import { declaredClasses, declaredProperties } from "../ontology.js";
+export const CONTEXT_FILES = ["contexts/core.jsonld", "contexts/di.jsonld"];
+export const loadContextTerms = () => {
+    const raw = {};
+    for (const file of CONTEXT_FILES) {
+        Object.assign(raw, JSON.parse(readFileSync(join(ROOT, file), "utf8"))["@context"]);
+    }
+    const expand = (value) => {
+        const [prefix, local] = value.split(":");
+        const base = raw[prefix];
+        return typeof base === "string" && local !== undefined ? `${base}${local}` : value;
+    };
+    const terms = {};
+    for (const [term, entry] of Object.entries(raw)) {
+        const id = typeof entry === "string" ? entry : entry["@id"];
+        if (id !== undefined && !id.startsWith("@"))
+            terms[term] = expand(id);
+    }
+    return terms;
+};
+const usedTerms = (tables) => {
+    const used = [];
+    const property = (term, where) => used.push({ term, kind: "property", where });
+    for (const [element, mapping] of Object.entries(tables.elements)) {
+        used.push({ term: mapping.type, kind: "class", where: `${element}.type` });
+        for (const [attribute, term] of Object.entries(mapping.attributes)) {
+            if (attribute !== "id")
+                property(term, `${element}.attributes.${attribute}`);
+        }
+        for (const field of ["singles", "textChildren", "textLists"]) {
+            for (const [child, term] of Object.entries(mapping[field] ?? {}))
+                property(term, `${element}.${field}.${child}`);
+        }
+        for (const lookup of mapping.lookups ?? [])
+            property(lookup.term, `${element}.lookups.${lookup.attribute}`);
+        for (const term of mapping.booleans ?? [])
+            property(term, `${element}.booleans`);
+        for (const term of mapping.numbers ?? [])
+            property(term, `${element}.numbers`);
+        if (mapping.bodyTerm !== undefined)
+            property(mapping.bodyTerm, `${element}.bodyTerm`);
+    }
+    for (const [element, children] of Object.entries(tables.containment)) {
+        for (const [child, term] of Object.entries(children))
+            property(term, `containment.${element}.${child}`);
+    }
+    return used;
+};
+export const checkMapping = (tables, store, context) => {
+    const classes = declaredClasses(store);
+    const properties = declaredProperties(store);
+    const problems = [];
+    for (const { term, kind, where } of usedTerms(tables)) {
+        const iri = context[term];
+        if (iri === undefined) {
+            problems.push({ term, kind, where, reason: "not-in-context" });
+        }
+        else if (!(kind === "class" ? classes : properties).has(iri)) {
+            problems.push({ term, kind, where, reason: "not-in-ontology" });
+        }
+    }
+    return problems;
+};

package/dist/convert/mapping.d.ts

@@ -0,0 +1,52 @@
+export declare const MODEL_NAMESPACE = "http://www.omg.org/spec/BPMN/20100524/MODEL";
+export declare const DI_NAMESPACE = "http://www.omg.org/spec/BPMN/20100524/DI";
+export declare const DC_NAMESPACE = "http://www.omg.org/spec/DD/20100524/DC";
+export declare const DD_NAMESPACE = "http://www.omg.org/spec/DD/20100524/DI";
+export declare const XSI_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance";
+export declare const BPMN_NAMESPACES: string[];
+export declare const REFERENCE_ATTRIBUTES: string[];
+export declare const REFERENCE_CHILDREN: string[];
+export interface ElementMapping {
+    consumed?: string[];
+    type: string;
+    attributes: Record<string, string>;
+    booleans?: string[];
+    hashPrefixed?: string[];
+    numbers?: string[];
+    textChildren?: Record<string, string>;
+    textLists?: Record<string, string>;
+    lookups?: Lookup[];
+    bodyTerm?: string;
+    singles?: Record<string, string>;
+    anonymous?: boolean;
+    requiresBody?: boolean;
+    requiresChild?: string;
+    derivedChildIds?: Record<string, string>;
+}
+export interface Lookup {
+    attribute: string;
+    root: string;
+    from: string;
+    term: string;
+    exportOnly?: boolean;
+}
+export declare const ELEMENT_MAPPINGS: Record<string, ElementMapping>;
+export declare const ELEMENT_NAMESPACES: Record<string, string>;
+export declare const isEmptyRequired: (element: {
+    name: string;
+    text: string;
+    children: {
+        name: string;
+    }[];
+}) => boolean;
+export declare const concreteElement: <T extends {
+    namespace: string;
+    name: string;
+    attributes: Record<string, string>;
+}>(element: T) => T;
+export declare const isMapped: (element: {
+    namespace: string;
+    name: string;
+}) => boolean;
+export declare const CONTAINMENT: Record<string, Record<string, string>>;
+export declare const ROOT_ELEMENTS: string[];

package/dist/convert/mapping.js

@@ -0,0 +1,273 @@
+export const MODEL_NAMESPACE = "http://www.omg.org/spec/BPMN/20100524/MODEL";
+export const DI_NAMESPACE = "http://www.omg.org/spec/BPMN/20100524/DI";
+export const DC_NAMESPACE = "http://www.omg.org/spec/DD/20100524/DC";
+export const DD_NAMESPACE = "http://www.omg.org/spec/DD/20100524/DI";
+export const XSI_NAMESPACE = "http://www.w3.org/2001/XMLSchema-instance";
+export const BPMN_NAMESPACES = [MODEL_NAMESPACE, DI_NAMESPACE, DC_NAMESPACE, DD_NAMESPACE];
+export const REFERENCE_ATTRIBUTES = [
+    "sourceRef",
+    "targetRef",
+    "attachedToRef",
+    "processRef",
+    "default",
+    "errorRef",
+    "activityRef",
+    "escalationRef",
+    "messageRef",
+    "operationRef",
+    "itemRef",
+    "signalRef",
+    "structureRef",
+    "evaluatesToTypeRef",
+    "partitionElementRef",
+    "bpmnElement",
+    "sourceElement",
+    "targetElement",
+];
+export const REFERENCE_CHILDREN = ["flowNodeRef", "operationRef", "source", "target", "eventDefinitionRef"];
+const named = { id: "id", name: "name" };
+const withDefault = { ...named, default: "default" };
+const implementedTasks = ["businessRuleTask", "userTask"];
+const tasks = ["manualTask", "receiveTask", "scriptTask", "sendTask", "serviceTask", ...implementedTasks];
+const withImplementation = { ...withDefault, implementation: "implementation" };
+const gateways = ["exclusiveGateway", "parallelGateway", "inclusiveGateway", "eventBasedGateway", "complexGateway"];
+const defaultableGateways = ["exclusiveGateway", "inclusiveGateway", "complexGateway"];
+const events = ["startEvent", "endEvent", "intermediateCatchEvent", "intermediateThrowEvent", "implicitThrowEvent", "boundaryEvent"];
+const definitions = [
+    "message",
+    "timer",
+    "error",
+    "signal",
+    "escalation",
+    "conditional",
+    "link",
+    "compensate",
+    "cancel",
+    "terminate",
+].map((kind) => `${kind}EventDefinition`);
+const capitalize = (name) => name[0].toUpperCase() + name.slice(1);
+const typed = (names, attributes = named, type) => Object.fromEntries(names.map((name) => [name, { type: type ?? capitalize(name), attributes }]));
+const expression = {
+    type: "FormalExpression",
+    attributes: { language: "language", evaluatesToTypeRef: "evaluatesToTypeRef" },
+    consumed: [`{${XSI_NAMESPACE}}type`],
+    bodyTerm: "body",
+    anonymous: true,
+    requiresBody: true,
+};
+const eventReferences = { eventDefinitionRef: "eventDefinitionRef" };
+export const ELEMENT_MAPPINGS = {
+    process: {
+        type: "Process",
+        attributes: { ...named, isExecutable: "isExecutable", processType: "processType", isClosed: "isClosed" },
+        booleans: ["isExecutable", "isClosed"],
+    },
+    subProcess: {
+        type: "SubProcess",
+        attributes: { ...withDefault, triggeredByEvent: "triggeredByEvent" },
+        booleans: ["triggeredByEvent"],
+    },
+    adHocSubProcess: {
+        type: "AdHocSubProcess",
+        attributes: { ...withDefault, triggeredByEvent: "triggeredByEvent", ordering: "ordering", cancelRemainingInstances: "cancelRemainingInstances" },
+        booleans: ["triggeredByEvent", "cancelRemainingInstances"],
+        singles: { completionCondition: "completionCondition" },
+    },
+    transaction: {
+        type: "Transaction",
+        attributes: { ...withDefault, triggeredByEvent: "triggeredByEvent", method: "method" },
+        booleans: ["triggeredByEvent"],
+        hashPrefixed: ["method"],
+    },
+    ...typed(["laneSet", "childLaneSet"], { id: "id" }, "LaneSet"),
+    lane: {
+        type: "Lane",
+        attributes: { ...named, partitionElementRef: "partitionElementRef" },
+        textLists: { flowNodeRef: "flowNodeRef" },
+        singles: { childLaneSet: "childLaneSet", partitionElement: "partitionElement" },
+    },
+    collaboration: { type: "Collaboration", attributes: { ...named, isClosed: "isClosed" }, booleans: ["isClosed"] },
+    participant: { type: "Participant", attributes: { ...named, processRef: "processRef" } },
+    association: {
+        type: "Association",
+        attributes: { ...named, sourceRef: "sourceRef", targetRef: "targetRef", associationDirection: "associationDirection" },
+    },
+    messageFlow: {
+        type: "MessageFlow",
+        attributes: { ...named, sourceRef: "sourceRef", targetRef: "targetRef", messageRef: "messageRef" },
+    },
+    message: { type: "Message", attributes: { ...named, itemRef: "itemRef" } },
+    signal: { type: "Signal", attributes: { ...named, structureRef: "structureRef" } },
+    error: { type: "Error", attributes: { ...named, errorCode: "errorCode", structureRef: "structureRef" } },
+    escalation: { type: "Escalation", attributes: { ...named, escalationCode: "escalationCode", structureRef: "structureRef" } },
+    task: { type: "ManualTask", attributes: withDefault },
+    ...typed(["manualTask"], withDefault),
+    ...typed(implementedTasks, withImplementation),
+    scriptTask: {
+        type: "ScriptTask",
+        attributes: { ...withDefault, scriptFormat: "scriptFormat" },
+        textChildren: { script: "script" },
+    },
+    serviceTask: { type: "ServiceTask", attributes: { ...withImplementation, operationRef: "operationRef" } },
+    sendTask: { type: "SendTask", attributes: { ...withImplementation, messageRef: "messageRef", operationRef: "operationRef" } },
+    receiveTask: {
+        type: "ReceiveTask",
+        attributes: { ...withImplementation, instantiate: "instantiate", messageRef: "messageRef", operationRef: "operationRef" },
+        booleans: ["instantiate"],
+    },
+    ...typed(events),
+    startEvent: {
+        type: "StartEvent",
+        attributes: { ...named, isInterrupting: "isInterrupting", parallelMultiple: "parallelMultiple" },
+        booleans: ["isInterrupting", "parallelMultiple"],
+    },
+    intermediateCatchEvent: {
+        type: "IntermediateCatchEvent",
+        attributes: { ...named, parallelMultiple: "parallelMultiple" },
+        booleans: ["parallelMultiple"],
+    },
+    ...typed(gateways, { ...named, gatewayDirection: "gatewayDirection" }),
+    eventBasedGateway: {
+        type: "EventBasedGateway",
+        attributes: { ...named, gatewayDirection: "gatewayDirection", instantiate: "instantiate", eventGatewayType: "eventGatewayType" },
+        booleans: ["instantiate"],
+    },
+    ...typed(defaultableGateways, { ...named, gatewayDirection: "gatewayDirection", default: "default" }),
+    complexGateway: {
+        type: "ComplexGateway",
+        attributes: { ...named, gatewayDirection: "gatewayDirection", default: "default" },
+        singles: { activationCondition: "activationCondition" },
+    },
+    ...typed(definitions),
+    conditionalEventDefinition: {
+        type: "ConditionalEventDefinition",
+        attributes: named,
+        singles: { condition: "condition" },
+    },
+    messageEventDefinition: {
+        type: "MessageEventDefinition",
+        attributes: { ...named, messageRef: "messageRef" },
+        textChildren: { operationRef: "operationRef" },
+    },
+    linkEventDefinition: {
+        type: "LinkEventDefinition",
+        attributes: named,
+        textLists: { source: "source" },
+        textChildren: { target: "target" },
+    },
+    signalEventDefinition: { type: "SignalEventDefinition", attributes: { ...named, signalRef: "signalRef" } },
+    boundaryEvent: {
+        type: "BoundaryEvent",
+        attributes: { ...named, attachedToRef: "attachedToRef", cancelActivity: "cancelActivity", parallelMultiple: "parallelMultiple" },
+        booleans: ["cancelActivity", "parallelMultiple"],
+    },
+    timerEventDefinition: {
+        type: "TimerEventDefinition",
+        attributes: named,
+        textChildren: { timeDate: "timeDate", timeDuration: "timeDuration", timeCycle: "timeCycle" },
+    },
+    errorEventDefinition: {
+        type: "ErrorEventDefinition",
+        attributes: { ...named, errorRef: "errorRef" },
+        lookups: [{ attribute: "errorRef", root: "error", from: "errorCode", term: "errorCode", exportOnly: true }],
+    },
+    escalationEventDefinition: {
+        type: "EscalationEventDefinition",
+        attributes: { ...named, escalationRef: "escalationRef" },
+        lookups: [{ attribute: "escalationRef", root: "escalation", from: "escalationCode", term: "escalationCode", exportOnly: true }],
+    },
+    compensateEventDefinition: {
+        type: "CompensateEventDefinition",
+        attributes: { ...named, waitForCompletion: "waitForCompletion", activityRef: "activityRef" },
+        booleans: ["waitForCompletion"],
+    },
+    sequenceFlow: {
+        type: "SequenceFlow",
+        attributes: { ...named, sourceRef: "sourceRef", targetRef: "targetRef", isImmediate: "isImmediate" },
+        booleans: ["isImmediate"],
+        singles: { conditionExpression: "conditionExpression" },
+    },
+    conditionExpression: expression,
+    completionCondition: expression,
+    condition: expression,
+    activationCondition: expression,
+};
+const diagramInterchange = {
+    BPMNDiagram: { type: "BPMNDiagram", attributes: { id: "id", name: "name", resolution: "resolution" }, numbers: ["resolution"], singles: { BPMNPlane: "plane" }, derivedChildIds: { plane: "Plane_" } },
+    BPMNPlane: { type: "BPMNPlane", attributes: { id: "id", bpmnElement: "bpmnElement" } },
+    BPMNShape: {
+        type: "BPMNShape",
+        attributes: { id: "id", bpmnElement: "bpmnElement", isExpanded: "isExpanded", isHorizontal: "isHorizontal", isMarkerVisible: "isMarkerVisible", isMessageVisible: "isMessageVisible" },
+        booleans: ["isExpanded", "isHorizontal", "isMarkerVisible", "isMessageVisible"],
+        singles: { Bounds: "bounds", BPMNLabel: "label" },
+    },
+    BPMNEdge: {
+        type: "BPMNEdge",
+        attributes: { id: "id", bpmnElement: "bpmnElement", sourceElement: "sourceElement", targetElement: "targetElement", messageVisibleKind: "messageVisibleKind" },
+        singles: { BPMNLabel: "label" },
+    },
+    BPMNLabel: { type: "BPMNLabel", attributes: {}, singles: { Bounds: "bounds" }, anonymous: true, requiresChild: "Bounds" },
+    Bounds: {
+        type: "Bounds",
+        attributes: { x: "x", y: "y", width: "width", height: "height" },
+        numbers: ["x", "y", "width", "height"],
+    },
+    waypoint: { type: "Point", attributes: { x: "x", y: "y" }, numbers: ["x", "y"] },
+};
+Object.assign(ELEMENT_MAPPINGS, diagramInterchange);
+for (const name of events) {
+    const mapping = ELEMENT_MAPPINGS[name];
+    ELEMENT_MAPPINGS[name] = { ...mapping, textLists: { ...mapping.textLists, ...eventReferences } };
+}
+const activityAttributes = { isForCompensation: "isForCompensation", startQuantity: "startQuantity", completionQuantity: "completionQuantity" };
+for (const name of [...tasks, "task", "subProcess", "adHocSubProcess", "transaction"]) {
+    const mapping = ELEMENT_MAPPINGS[name];
+    ELEMENT_MAPPINGS[name] = {
+        ...mapping,
+        attributes: { ...mapping.attributes, ...activityAttributes },
+        booleans: [...(mapping.booleans ?? []), "isForCompensation"],
+        numbers: [...(mapping.numbers ?? []), "startQuantity", "completionQuantity"],
+    };
+}
+export const ELEMENT_NAMESPACES = {
+    BPMNDiagram: DI_NAMESPACE,
+    BPMNPlane: DI_NAMESPACE,
+    BPMNShape: DI_NAMESPACE,
+    BPMNEdge: DI_NAMESPACE,
+    BPMNLabel: DI_NAMESPACE,
+    Bounds: DC_NAMESPACE,
+    waypoint: DD_NAMESPACE,
+};
+export const isEmptyRequired = (element) => {
+    const mapping = ELEMENT_MAPPINGS[element.name];
+    return ((mapping?.requiresBody === true && element.text === "") ||
+        (mapping?.requiresChild !== undefined && !element.children.some((child) => child.name === mapping.requiresChild)));
+};
+const XSI_TYPE = `{${XSI_NAMESPACE}}type`;
+export const concreteElement = (element) => {
+    const declared = element.name === "partitionElement" && element.namespace === MODEL_NAMESPACE ? element.attributes[XSI_TYPE] : undefined;
+    const local = declared?.slice(declared.indexOf(":") + 1);
+    const name = local !== undefined && /^t[A-Z]/.test(local) ? local[1].toLowerCase() + local.slice(2) : undefined;
+    return name !== undefined && name in ELEMENT_MAPPINGS && ELEMENT_NAMESPACES[name] === undefined ? { ...element, name } : element;
+};
+export const isMapped = (element) => element.namespace === (ELEMENT_NAMESPACES[element.name] ?? MODEL_NAMESPACE) && element.name in ELEMENT_MAPPINGS;
+const eventContainment = Object.fromEntries(definitions.map((name) => [name, "eventDefinitions"]));
+const container = {
+    ...Object.fromEntries([...tasks, "task", ...events, ...gateways, "subProcess", "adHocSubProcess", "transaction", "sequenceFlow"].map((name) => [name, "flowElements"])),
+    laneSet: "laneSets",
+    association: "artifacts",
+};
+const planeContainment = { BPMNShape: "planeElements", BPMNEdge: "planeElements" };
+export const CONTAINMENT = {
+    process: container,
+    subProcess: container,
+    adHocSubProcess: container,
+    transaction: container,
+    collaboration: { participant: "participants", messageFlow: "messageFlows" },
+    BPMNPlane: planeContainment,
+    BPMNEdge: { waypoint: "waypoints" },
+    laneSet: { lane: "lanes" },
+    childLaneSet: { lane: "lanes" },
+    ...Object.fromEntries(events.map((event) => [event, eventContainment])),
+};
+export const ROOT_ELEMENTS = ["message", "signal", "error", "escalation", ...definitions, "collaboration", "process", "BPMNDiagram"];

package/dist/convert/namespaces.d.ts

@@ -0,0 +1,2 @@
+import type { XmlElement } from "./xml-reader.ts";
+export declare const assertSupportedNamespaces: (element: XmlElement) => void;

package/dist/convert/namespaces.js

@@ -0,0 +1,19 @@
+import { ConversionError } from "./errors.js";
+import { BPMN_NAMESPACES } from "./mapping.js";
+const BPMN_FAMILY = /^https?:\/\/(?:www\.|schema\.)?omg\.org\/(?:spec\/(?:BPMN|DD)\/\d|bpmn)/i;
+const ATTRIBUTE_NAMESPACE = /^\{(.*)\}(.*)$/;
+const isUnrecognisedBpmn = (namespace) => BPMN_FAMILY.test(namespace) && !BPMN_NAMESPACES.includes(namespace);
+const reject = (namespace, construct, location) => {
+    throw new ConversionError("unrecognised-bpmn-namespace", `unrecognised BPMN namespace ${namespace} on ${construct} at ${location}; supported namespaces are ${BPMN_NAMESPACES.join(", ")}`);
+};
+export const assertSupportedNamespaces = (element) => {
+    if (isUnrecognisedBpmn(element.namespace))
+        reject(element.namespace, element.name, element.location);
+    for (const key of Object.keys(element.attributes)) {
+        const match = ATTRIBUTE_NAMESPACE.exec(key);
+        if (match && isUnrecognisedBpmn(match[1]))
+            reject(match[1], `${element.name}@${match[2]}`, `${element.location}/@${match[2]}`);
+    }
+    for (const child of element.children)
+        assertSupportedNamespaces(child);
+};

package/dist/convert/validate-output.d.ts

@@ -0,0 +1,2 @@
+import type { ConvertResult } from "./convert.ts";
+export declare const validateConverted: (document: ConvertResult["document"]) => Promise<string[]>;

package/dist/convert/validate-output.js

@@ -0,0 +1,28 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ROOT } from "../paths.js";
+import { compileSchema, validateWithSchema } from "../schema-validate.js";
+import { validateShacl } from "../shacl.js";
+import { validateExample } from "../validate.js";
+export const validateConverted = async (document) => {
+    const errors = validateWithSchema(document, compileSchema()).map((e) => `schema: ${e}`);
+    const local = { ...document, "@context": [join(ROOT, "contexts/combined.jsonld"), document["@context"][1]] };
+    const directory = mkdtempSync(join(tmpdir(), "convert-"));
+    try {
+        const file = join(directory, "out.jsonld");
+        writeFileSync(file, JSON.stringify(local));
+        const structural = await validateExample(file);
+        errors.push(...structural.errors);
+        if (structural.valid) {
+            const shacl = await validateShacl(file);
+            shacl.violations.forEach((v) => errors.push(`shacl: ${v.focusNode} violates ${v.sourceShape}`));
+            if (!shacl.conforms && shacl.violations.length === 0)
+                errors.push("shacl: validation failed");
+        }
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+    return errors;
+};

package/dist/convert/warnings.d.ts

@@ -0,0 +1,9 @@
+import { type XmlElement } from "./xml-reader.ts";
+export type WarningKind = "foreign-namespace" | "unsupported" | "dangling-reference";
+export interface Warning {
+    kind: WarningKind;
+    construct: string;
+    location: string;
+    message?: string;
+}
+export declare const collectWarnings: (root: XmlElement) => Warning[];

package/dist/convert/warnings.js

@@ -0,0 +1,67 @@
+import { BPMN_NAMESPACES, CONTAINMENT, concreteElement, ELEMENT_MAPPINGS, isEmptyRequired, isMapped, MODEL_NAMESPACE, REFERENCE_ATTRIBUTES, REFERENCE_CHILDREN, ROOT_ELEMENTS, XSI_NAMESPACE, } from "./mapping.js";
+import { extensionWarnings, isExtensionAttribute } from "./extensions.js";
+import { collectIds } from "./xml-reader.js";
+const ATTRIBUTE_NAMESPACE = /^\{(.*)\}(.*)$/;
+const XML_NAMESPACES = [XSI_NAMESPACE, "xml", "http://www.w3.org/XML/1998/namespace"];
+const mappedAttributes = (element) => {
+    const mapping = isMapped(element) ? ELEMENT_MAPPINGS[element.name] : undefined;
+    return new Set([...Object.keys(mapping?.attributes ?? {}), ...(mapping?.consumed ?? []), ...(mapping?.lookups ?? []).map((lookup) => lookup.attribute)]);
+};
+const consumedRoots = new Set(Object.values(ELEMENT_MAPPINGS).flatMap((mapping) => (mapping.lookups ?? []).map((lookup) => lookup.root)));
+const isHandledChild = (parent, child) => {
+    if (parent.name === "definitions")
+        return (isMapped(child) && ROOT_ELEMENTS.includes(child.name)) || (child.namespace === MODEL_NAMESPACE && consumedRoots.has(child.name));
+    const mapping = ELEMENT_MAPPINGS[parent.name];
+    if (child.namespace === MODEL_NAMESPACE && child.name === "extensionElements")
+        return true;
+    if (child.namespace === MODEL_NAMESPACE && (child.name in (mapping.textChildren ?? {}) || child.name in (mapping.textLists ?? {})))
+        return true;
+    return isMapped(concreteElement(child)) && (child.name in (mapping.singles ?? {}) || child.name in (CONTAINMENT[parent.name] ?? {}));
+};
+const attributeWarnings = (element, ids) => {
+    const allowed = mappedAttributes(element);
+    return Object.keys(element.attributes).flatMap((key) => {
+        if (allowed.has(key)) {
+            const dangling = REFERENCE_ATTRIBUTES.includes(key) && !ids.has(element.attributes[key]);
+            return dangling ? [{ kind: "dangling-reference", construct: `${element.name}@${key}`, location: `${element.location}/@${key}` }] : [];
+        }
+        if (isMapped(element) && isExtensionAttribute(key))
+            return [];
+        const foreign = ATTRIBUTE_NAMESPACE.exec(key);
+        if (foreign && XML_NAMESPACES.includes(foreign[1]))
+            return [];
+        const location = `${element.location}/@${foreign ? foreign[2] : key}`;
+        if (foreign)
+            return [{ kind: "foreign-namespace", construct: `${element.name}@${foreign[2]}`, location }];
+        return [{ kind: "unsupported", construct: `${element.name}@${key}`, location }];
+    });
+};
+const dropped = (element) => element.name === "extensionElements" && element.namespace === MODEL_NAMESPACE
+    ? element.children.map((child) => ({ kind: "foreign-namespace", construct: child.name, location: child.location }))
+    : [
+        {
+            kind: BPMN_NAMESPACES.includes(element.namespace) ? "unsupported" : "foreign-namespace",
+            construct: element.name,
+            location: element.location,
+        },
+    ];
+const childWarnings = (parent, child, ids) => {
+    if (!isHandledChild(parent, child))
+        return dropped(child);
+    if (isMapped(concreteElement(child)))
+        return walk(concreteElement(child), ids);
+    if (child.name === "extensionElements")
+        return extensionWarnings(child);
+    const dangling = REFERENCE_CHILDREN.includes(child.name) && !ids.has(child.text);
+    return dangling ? [{ kind: "dangling-reference", construct: child.name, location: child.location }] : [];
+};
+const lossyWarnings = (element) => {
+    const lossy = isMapped(element) && (element.name === "task" || isEmptyRequired(element));
+    return lossy ? [{ kind: "unsupported", construct: element.name, location: element.location }] : [];
+};
+const walk = (element, ids) => [
+    ...lossyWarnings(element),
+    ...attributeWarnings(element, ids),
+    ...element.children.flatMap((child) => childWarnings(element, child, ids)),
+];
+export const collectWarnings = (root) => walk(root, collectIds(root));

package/dist/convert/xml-reader.d.ts

@@ -0,0 +1,11 @@
+export interface XmlElement {
+    namespace: string;
+    name: string;
+    attributes: Record<string, string>;
+    declarations: [string, string][];
+    children: XmlElement[];
+    text: string;
+    location: string;
+}
+export declare const readXml: (xml: string) => XmlElement;
+export declare const collectIds: (element: XmlElement, ids?: Set<string>) => Set<string>;