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

package/dist/layout/standalone.js

@@ -0,0 +1,50 @@
+import { arrangeLanes, bandsBottom, buildLaneLayout, extendLastBand, laneBoxes, laneBoxesFromNodes, LANE_HEADER } from "./lanes.js";
+import { allNodes } from "./model.js";
+import { measure, ORIGIN, placeScope } from "./placement.js";
+const MARGIN = 20;
+export const placeStandalone = (model, lanes, existing = { fixed: new Map(), obstacles: new Map() }) => {
+    measure(model);
+    const laneLayout = lanes ? buildLaneLayout(lanes, model) : undefined;
+    const context = {
+        fixed: existing.fixed,
+        obstacles: existing.obstacles,
+        missingFlows: existing.missingFlows,
+        boxes: new Map(),
+        routes: new Map(),
+        lanes: new Map(),
+        arrange: laneLayout ? (scope, layering, layered, origin) => (scope === model ? arrangeLanes(laneLayout, scope, layering, layered, origin) : undefined) : undefined,
+    };
+    const indent = laneLayout ? LANE_HEADER * (laneLayout.depth + 1) + MARGIN : 0;
+    placeScope(model, { x: ORIGIN.x + indent, y: ORIGIN.y }, context);
+    const result = { boxes: context.boxes, routes: context.routes, lanes: new Map() };
+    const nested = () => {
+        for (const [id, box] of context.lanes)
+            result.lanes.set(id, existing.fixed.get(id) ?? box);
+    };
+    if (!laneLayout) {
+        nested();
+        return result;
+    }
+    const anchored = allNodes(model).some((node) => existing.fixed.has(node.id));
+    const boxes = [...context.boxes.values()];
+    const points = [...context.routes.values()].flat();
+    const right = Math.max(...boxes.map((box) => box.x + box.width), ...points.map((point) => point.x)) + MARGIN;
+    let frame;
+    let computed;
+    if (anchored) {
+        const x = Math.min(...boxes.map((box) => box.x)) - indent;
+        const y = Math.min(...boxes.map((box) => box.y)) - MARGIN;
+        const bottom = Math.max(...boxes.map((box) => box.y + box.height), ...points.map((point) => point.y)) + MARGIN;
+        frame = { x, y, width: right - x, height: bottom - y };
+        computed = laneBoxesFromNodes(laneLayout, frame, context.boxes, 0);
+    }
+    else {
+        extendLastBand(laneLayout, Math.max(...points.map((point) => point.y), ...boxes.map((box) => box.y + box.height), 0) + MARGIN / 2);
+        frame = { x: ORIGIN.x, y: ORIGIN.y, width: right - ORIGIN.x, height: bandsBottom(laneLayout) - ORIGIN.y };
+        computed = laneBoxes(laneLayout, frame, 0);
+    }
+    for (const lane of laneLayout.lanes)
+        result.lanes.set(lane.id, existing.fixed.get(lane.id) ?? computed.get(lane.id));
+    nested();
+    return result;
+};

package/dist/layout-cli.d.ts

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

package/dist/layout-cli.js

@@ -0,0 +1,5 @@
+import { runLayout } from "./layout-run.js";
+const { exitCode, stdout, stderr } = runLayout(process.argv.slice(2));
+process.stdout.write(stdout);
+process.stderr.write(stderr);
+process.exitCode = exitCode;

package/dist/layout-run.d.ts

@@ -0,0 +1,9 @@
+export declare const EXIT_OK = 0;
+export declare const EXIT_BAD_INPUT = 2;
+export interface CliResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const USAGE = "Usage: layout <input.jsonld> [options]\n\nAdds BPMN DI (shapes, edges and waypoints) to a BPMN-LD document and writes the\nresult as JSON-LD. A process that already has a diagram is completed: shapes and\nedges are added only for flow nodes and sequence flows that lack them, placed\naround the existing shapes, and existing diagram content is never changed.\nWith --force the diagram of each process is replaced by a fresh full layout.\n\nOptions:\n  -o, --output <file>  Write the document to <file> instead of standard output\n      --force          Recompute all shapes and edges, replacing existing diagrams\n  -h, --help           Show this help\n\nExit codes:\n  0  Laid out successfully\n  2  Usage error or unusable input (missing file, invalid JSON, invalid BPMN-LD)\n";
+export declare const runLayout: (argv: string[]) => CliResult;

package/dist/layout-run.js

@@ -0,0 +1,105 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { layoutDocument, LayoutInputError } from "./layout/layout.js";
+export const EXIT_OK = 0;
+export const EXIT_BAD_INPUT = 2;
+const MAX_REPORTED_ERRORS = 10;
+export const USAGE = `Usage: layout <input.jsonld> [options]
+
+Adds BPMN DI (shapes, edges and waypoints) to a BPMN-LD document and writes the
+result as JSON-LD. A process that already has a diagram is completed: shapes and
+edges are added only for flow nodes and sequence flows that lack them, placed
+around the existing shapes, and existing diagram content is never changed.
+With --force the diagram of each process is replaced by a fresh full layout.
+
+Options:
+  -o, --output <file>  Write the document to <file> instead of standard output
+      --force          Recompute all shapes and edges, replacing existing diagrams
+  -h, --help           Show this help
+
+Exit codes:
+  0  Laid out successfully
+  2  Usage error or unusable input (missing file, invalid JSON, invalid BPMN-LD)
+`;
+class UsageError extends Error {
+}
+const parseArgs = (argv) => {
+    let output;
+    let input;
+    let force = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-h" || arg === "--help")
+            return "help";
+        else if (arg === "--force")
+            force = true;
+        else if (arg === "-o" || arg === "--output") {
+            const value = argv[++i];
+            if (value === undefined || value.startsWith("-"))
+                throw new UsageError(`${arg} requires a value`);
+            output = value;
+        }
+        else if (arg.startsWith("-"))
+            throw new UsageError(`unknown option ${arg}`);
+        else if (input !== undefined)
+            throw new UsageError(`unexpected extra argument ${arg}`);
+        else
+            input = arg;
+    }
+    if (input === undefined)
+        throw new UsageError("missing input file");
+    return { input, output, force };
+};
+const failure = (stderr) => ({ exitCode: EXIT_BAD_INPUT, stdout: "", stderr });
+const readJson = (path) => {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        const reason = error.code === "ENOENT" ? "no such file" : (error.message ?? "cannot read");
+        throw new UsageError(`cannot read ${path}: ${reason}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new UsageError(`${path} is not valid JSON: ${error.message}`);
+    }
+};
+export const runLayout = (argv) => {
+    let options;
+    let document;
+    try {
+        options = parseArgs(argv);
+        if (options === "help")
+            return { exitCode: EXIT_OK, stdout: USAGE, stderr: "" };
+        document = readJson(options.input);
+    }
+    catch (error) {
+        if (error instanceof UsageError)
+            return failure(`error: ${error.message}\n\n${USAGE}`);
+        throw error;
+    }
+    let text;
+    try {
+        text = `${JSON.stringify(layoutDocument(document, { force: options.force }).document, null, 2)}\n`;
+    }
+    catch (error) {
+        if (!(error instanceof LayoutInputError))
+            throw error;
+        const shown = error.errors.slice(0, MAX_REPORTED_ERRORS).map((e) => `error: ${options.input}: invalid BPMN-LD: ${e}`);
+        const more = error.errors.length - shown.length;
+        if (more > 0)
+            shown.push(`error: ... and ${more} more`);
+        return failure(`${shown.join("\n")}\n`);
+    }
+    if (options.output === undefined)
+        return { exitCode: EXIT_OK, stdout: text, stderr: "" };
+    try {
+        writeFileSync(options.output, text);
+    }
+    catch (error) {
+        return failure(`error: cannot write ${options.output}: ${error.message}\n`);
+    }
+    return { exitCode: EXIT_OK, stdout: "", stderr: "" };
+};

package/dist/loader.d.ts

@@ -0,0 +1,5 @@
+export declare const fileDocumentLoader: (url: string) => Promise<{
+    contextUrl: undefined;
+    document: any;
+    documentUrl: string;
+}>;

package/dist/loader.js

@@ -0,0 +1,7 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+export const fileDocumentLoader = async (url) => {
+    if (!url.startsWith("file:"))
+        throw new Error(`Only file: URLs can be loaded, got ${url}`);
+    return { contextUrl: undefined, document: JSON.parse(await readFile(fileURLToPath(url), "utf8")), documentUrl: url };
+};

package/dist/namespace.d.ts

@@ -0,0 +1,5 @@
+export declare const BPMN_NAMESPACE = "https://bpmn-ld.example.org/ns#";
+export declare const BPMN_ONTOLOGY_IRI: string;
+export declare const BPMNDI_NAMESPACE = "https://bpmn-ld.example.org/di#";
+export declare const BPMNDI_ONTOLOGY_IRI: string;
+export declare const BPMN_SHAPES_NAMESPACE: string;

package/dist/namespace.js

@@ -0,0 +1,5 @@
+export const BPMN_NAMESPACE = "https://bpmn-ld.example.org/ns#";
+export const BPMN_ONTOLOGY_IRI = BPMN_NAMESPACE.replace(/#$/, "");
+export const BPMNDI_NAMESPACE = "https://bpmn-ld.example.org/di#";
+export const BPMNDI_ONTOLOGY_IRI = BPMNDI_NAMESPACE.replace(/#$/, "");
+export const BPMN_SHAPES_NAMESPACE = `${BPMN_ONTOLOGY_IRI}/shapes#`;

package/dist/ontology.d.ts

@@ -0,0 +1,19 @@
+import { Store } from "n3";
+export declare const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+export declare const RDFS_SUBCLASS_OF = "http://www.w3.org/2000/01/rdf-schema#subClassOf";
+export declare const RDFS_DOMAIN = "http://www.w3.org/2000/01/rdf-schema#domain";
+export declare const RDFS_RANGE = "http://www.w3.org/2000/01/rdf-schema#range";
+export declare const parseOntology: (turtle: string) => Store<import("n3").Quad, import("n3").Quad, import("@rdfjs/types").Quad, import("@rdfjs/types").Quad>;
+export declare const ONTOLOGY_FILES: string[];
+export declare const isOwnedIri: (iri: string) => boolean;
+export declare const loadOntology: () => Store<import("n3").Quad, import("n3").Quad, import("@rdfjs/types").Quad, import("@rdfjs/types").Quad>;
+export declare const declaredClasses: (store: Store) => Set<string>;
+export declare const declaredProperties: (store: Store) => Set<string>;
+export declare const declaredIndividuals: (store: Store) => Set<string>;
+export declare const declaredTerms: (store: Store) => Set<string>;
+export declare const typesOf: (store: Store, subject: string) => string[];
+export declare const superClasses: (store: Store, cls: string) => Set<string>;
+export declare const isSubClassOf: (store: Store, cls: string, ancestor: string) => boolean;
+export declare const domainAlternatives: (store: Store, property: string) => string[][];
+export declare const rangeAlternatives: (store: Store, property: string) => string[][];
+export declare const checkOntology: (store: Store) => string[];

package/dist/ontology.js

@@ -0,0 +1,94 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { Parser, Store } from "n3";
+import { ROOT } from "./paths.js";
+import { BPMN_NAMESPACE, BPMNDI_NAMESPACE } from "./namespace.js";
+export const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+export const RDFS_SUBCLASS_OF = "http://www.w3.org/2000/01/rdf-schema#subClassOf";
+export const RDFS_DOMAIN = "http://www.w3.org/2000/01/rdf-schema#domain";
+export const RDFS_RANGE = "http://www.w3.org/2000/01/rdf-schema#range";
+const OWL = "http://www.w3.org/2002/07/owl#";
+const OWL_UNION_OF = `${OWL}unionOf`;
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const RDF_FIRST = `${RDF}first`;
+const RDF_REST = `${RDF}rest`;
+const RDF_NIL = `${RDF}nil`;
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const CLASS_TYPES = [`${OWL}Class`];
+const PROPERTY_TYPES = [`${OWL}ObjectProperty`, `${OWL}DatatypeProperty`];
+export const parseOntology = (turtle) => new Store(new Parser().parse(turtle));
+export const ONTOLOGY_FILES = ["ontology/core.ttl", "ontology/di.ttl"];
+export const isOwnedIri = (iri) => iri.startsWith(BPMN_NAMESPACE) || iri.startsWith(BPMNDI_NAMESPACE);
+export const loadOntology = () => parseOntology(ONTOLOGY_FILES.map((file) => readFileSync(join(ROOT, file), "utf8")).join("\n"));
+const subjectsOfTypes = (store, types) => types.flatMap((type) => store.getSubjects(RDF_TYPE, type, null).map((s) => s.value));
+export const declaredClasses = (store) => new Set(subjectsOfTypes(store, CLASS_TYPES));
+export const declaredProperties = (store) => new Set(subjectsOfTypes(store, PROPERTY_TYPES));
+export const declaredIndividuals = (store) => new Set(subjectsOfTypes(store, [`${OWL}NamedIndividual`]));
+export const declaredTerms = (store) => new Set([...declaredClasses(store), ...declaredProperties(store), ...declaredIndividuals(store)]);
+export const typesOf = (store, subject) => store.getObjects(subject, RDF_TYPE, null).map((o) => o.value);
+export const superClasses = (store, cls) => {
+    const seen = new Set();
+    const pending = [cls];
+    while (pending.length) {
+        for (const parent of store.getObjects(pending.pop(), RDFS_SUBCLASS_OF, null)) {
+            if (!seen.has(parent.value)) {
+                seen.add(parent.value);
+                pending.push(parent.value);
+            }
+        }
+    }
+    return seen;
+};
+export const isSubClassOf = (store, cls, ancestor) => cls === ancestor || superClasses(store, cls).has(ancestor);
+const listMembers = (store, head) => {
+    const members = [];
+    let node = head;
+    while (node.value !== RDF_NIL) {
+        const [first] = store.getObjects(node, RDF_FIRST, null);
+        const [rest] = store.getObjects(node, RDF_REST, null);
+        if (!first || !rest)
+            break;
+        members.push(first.value);
+        node = rest;
+    }
+    return members;
+};
+const alternativesOf = (store, property, predicate) => store.getObjects(property, predicate, null).map((target) => {
+    const [union] = store.getObjects(target, OWL_UNION_OF, null);
+    return union ? listMembers(store, union) : [target.value];
+});
+export const domainAlternatives = (store, property) => alternativesOf(store, property, RDFS_DOMAIN);
+export const rangeAlternatives = (store, property) => alternativesOf(store, property, RDFS_RANGE);
+export const checkOntology = (store) => {
+    const errors = [];
+    const classes = declaredClasses(store);
+    const properties = declaredProperties(store);
+    const declared = declaredTerms(store);
+    for (const quad of store.getQuads(null, null, null, null)) {
+        for (const term of [quad.subject, quad.predicate, quad.object]) {
+            if (term.termType === "NamedNode" && isOwnedIri(term.value) && !declared.has(term.value)) {
+                errors.push(`${term.value} is used but not declared`);
+            }
+        }
+    }
+    for (const property of properties) {
+        for (const alternatives of domainAlternatives(store, property)) {
+            for (const domain of alternatives) {
+                if (!classes.has(domain))
+                    errors.push(`domain ${domain} of ${property} is not a declared class`);
+            }
+        }
+        for (const alternatives of rangeAlternatives(store, property)) {
+            for (const range of alternatives) {
+                if (!classes.has(range) && !range.startsWith(XSD)) {
+                    errors.push(`range ${range} of ${property} is not a declared class or datatype`);
+                }
+            }
+        }
+    }
+    for (const cls of classes) {
+        if (superClasses(store, cls).has(cls))
+            errors.push(`class hierarchy has a cycle through ${cls}`);
+    }
+    return [...new Set(errors)];
+};

package/dist/paths.d.ts

@@ -0,0 +1 @@
+export declare const ROOT: string;

package/dist/paths.js

@@ -0,0 +1,2 @@
+import { fileURLToPath } from "node:url";
+export const ROOT = fileURLToPath(new URL("..", import.meta.url));

package/dist/render/geometry.d.ts

@@ -0,0 +1,40 @@
+import type { Json } from "../export/element.ts";
+export interface Bounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface DiagramLabel {
+    bounds?: Bounds;
+}
+export interface DiagramShape {
+    id: string;
+    bpmnElement: string;
+    element?: Json;
+    bounds: Bounds;
+    isExpanded?: boolean;
+    isHorizontal?: boolean;
+    isMarkerVisible?: boolean;
+    label?: DiagramLabel;
+}
+export interface DiagramEdge {
+    id: string;
+    bpmnElement: string;
+    element?: Json;
+    waypoints: Point[];
+    label?: DiagramLabel;
+}
+export interface Diagram {
+    id: string;
+    name?: string;
+    bpmnElement?: string;
+    resolution?: number;
+    shapes: DiagramShape[];
+    edges: DiagramEdge[];
+}
+export declare const geometryDiagrams: (document: Json) => Diagram[];

package/dist/render/geometry.js

@@ -0,0 +1,81 @@
+const isBounds = (value) => typeof value === "object" && value !== null && ["x", "y", "width", "height"].every((key) => Number.isFinite(value[key]));
+const point = (value) => {
+    if (!Number.isFinite(value.x) || !Number.isFinite(value.y))
+        return undefined;
+    return { x: Number(value.x), y: Number(value.y) };
+};
+const shapeFrom = (node, byId) => {
+    if (typeof node.id !== "string" || typeof node.bpmnElement !== "string" || !isBounds(node.bounds))
+        return undefined;
+    return {
+        id: node.id,
+        bpmnElement: node.bpmnElement,
+        element: byId.get(node.bpmnElement),
+        bounds: node.bounds,
+        isExpanded: node.isExpanded === false ? false : node.isExpanded === true ? true : undefined,
+        isHorizontal: node.isHorizontal === true ? true : undefined,
+        isMarkerVisible: node.isMarkerVisible === true ? true : undefined,
+        label: typeof node.label === "object" && node.label !== null ? { bounds: isBounds(node.label.bounds) ? node.label.bounds : undefined } : undefined,
+    };
+};
+const edgeFrom = (node, byId) => {
+    if (typeof node.id !== "string" || typeof node.bpmnElement !== "string")
+        return undefined;
+    const waypoints = Array.isArray(node.waypoints) ? node.waypoints.map((item) => point(item)).filter((item) => item !== undefined) : [];
+    if (waypoints.length === 0)
+        return undefined;
+    return {
+        id: node.id,
+        bpmnElement: node.bpmnElement,
+        element: byId.get(node.bpmnElement),
+        waypoints,
+        label: typeof node.label === "object" && node.label !== null ? { bounds: isBounds(node.label.bounds) ? node.label.bounds : undefined } : undefined,
+    };
+};
+export const geometryDiagrams = (document) => {
+    const graph = Array.isArray(document["@graph"]) ? document["@graph"] : [document];
+    const byId = new Map();
+    const visit = (value) => {
+        if (Array.isArray(value))
+            value.forEach(visit);
+        else if (value && typeof value === "object") {
+            const node = value;
+            if (typeof node.id === "string")
+                byId.set(node.id, node);
+            Object.values(node).forEach(visit);
+        }
+    };
+    visit(graph);
+    const diagrams = [];
+    for (const node of graph) {
+        if (node?.type !== "BPMNDiagram" || typeof node.id !== "string")
+            continue;
+        const plane = node.plane;
+        if (!plane || typeof plane !== "object")
+            continue;
+        const elements = Array.isArray(plane.planeElements) ? plane.planeElements : [];
+        const shapes = [];
+        const edges = [];
+        for (const element of elements) {
+            if (element?.type === "BPMNShape") {
+                const shape = shapeFrom(element, byId);
+                if (shape)
+                    shapes.push(shape);
+            }
+            else if (element?.type === "BPMNEdge") {
+                const edge = edgeFrom(element, byId);
+                if (edge)
+                    edges.push(edge);
+            }
+        }
+        diagrams.push({
+            id: node.id,
+            name: typeof node.name === "string" ? node.name : undefined,
+            bpmnElement: typeof plane.bpmnElement === "string" ? plane.bpmnElement : undefined,
+            resolution: typeof node.resolution === "number" ? node.resolution : undefined,
+            shapes,
+            edges,
+        });
+    }
+    return diagrams;
+};

package/dist/render/renderer.d.ts

@@ -0,0 +1,31 @@
+import { type Diagram } from "./geometry.ts";
+import type { Json } from "../export/element.ts";
+export interface RenderWarning {
+    kind: "unsupported";
+    code: string;
+    construct: string;
+    location: string;
+    node?: string;
+    message?: string;
+}
+export interface RenderError {
+    code: string;
+    message: string;
+}
+export interface RenderedDiagram {
+    id: string;
+    name?: string;
+    svg: string;
+    warnings: RenderWarning[];
+    errors: RenderError[];
+}
+export interface RenderedDocument {
+    diagrams: RenderedDiagram[];
+    warnings: RenderWarning[];
+    errors: RenderError[];
+}
+export declare const renderDiagramSvg: (diagram: Diagram) => {
+    svg: string;
+    warnings: RenderWarning[];
+};
+export declare const renderDocument: (document: Json) => RenderedDocument;