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

package/dist/layout/placement.js

@@ -0,0 +1,256 @@
+import { assignLayers } from "./layering.js";
+export const ORIGIN = { x: 100, y: 100 };
+const LAYER_GAP = 60;
+export const ROW_GAP = 40;
+const LOOP_CLEARANCE = 30;
+const CONTAINER_MARGIN = 30;
+const BOUNDARY_SIZE = 36;
+const BOUNDARY_PITCH = 44;
+const ACTIVITY_SIZE = { width: 100, height: 80 };
+const DATA_GAP = 40;
+const DATA_SPACING = 20;
+const STUB_LENGTH = 40;
+const boundariesOf = (model, hostId) => model.nodes.filter((node) => node.attachedTo === hostId);
+export const reserveBelow = (model, hostId) => {
+    const count = boundariesOf(model, hostId).length;
+    return count === 0 ? 0 : BOUNDARY_SIZE / 2 + 10 + 8 * count;
+};
+export const boundaryBox = (model, node, host) => {
+    const siblings = boundariesOf(model, node.attachedTo);
+    const span = siblings.length * BOUNDARY_PITCH - (BOUNDARY_PITCH - BOUNDARY_SIZE);
+    return {
+        x: host.x + Math.round((host.width - span) / 2) + siblings.indexOf(node) * BOUNDARY_PITCH,
+        y: host.y + host.height - BOUNDARY_SIZE / 2,
+        width: BOUNDARY_SIZE,
+        height: BOUNDARY_SIZE,
+    };
+};
+export const placeNodes = (model, layering, origin = ORIGIN) => {
+    const sizes = new Map(model.nodes.map((node) => [node.id, node.size]));
+    const slot = (id) => sizes.get(id).height + reserveBelow(model, id);
+    const columnWidths = layering.layers.map((layer) => Math.max(0, ...layer.map((id) => sizes.get(id).width)));
+    const columnHeights = layering.layers.map((layer) => layer.reduce((sum, id) => sum + slot(id), 0) + ROW_GAP * Math.max(0, layer.length - 1));
+    const tallest = Math.max(0, ...columnHeights);
+    const boxes = new Map();
+    let x = origin.x;
+    layering.layers.forEach((layer, index) => {
+        let y = origin.y + (tallest - columnHeights[index]) / 2;
+        for (const id of layer) {
+            const { width, height } = sizes.get(id);
+            boxes.set(id, { x: x + (columnWidths[index] - width) / 2, y, width, height });
+            y += slot(id) + ROW_GAP;
+        }
+        x += columnWidths[index] + LAYER_GAP;
+    });
+    for (const node of model.nodes)
+        if (node.attachedTo)
+            boxes.set(node.id, boundaryBox(model, node, boxes.get(node.attachedTo)));
+    return boxes;
+};
+const centerY = (box) => box.y + box.height / 2;
+const centerX = (box) => box.x + box.width / 2;
+const dedupe = (points) => points.filter((point, index) => index === 0 || point.x !== points[index - 1].x || point.y !== points[index - 1].y);
+const routeForward = (source, target) => {
+    const start = { x: source.x + source.width, y: centerY(source) };
+    const end = { x: target.x, y: centerY(target) };
+    if (start.y === end.y)
+        return [start, end];
+    const middle = Math.round((start.x + end.x) / 2);
+    return [start, { x: middle, y: start.y }, { x: middle, y: end.y }, end];
+};
+const routeBack = (source, target, floor) => {
+    const lane = floor + LOOP_CLEARANCE;
+    const start = { x: centerX(source), y: source.y + source.height };
+    const end = { x: centerX(target), y: target.y + target.height };
+    return [start, { x: start.x, y: lane }, { x: end.x, y: lane }, end];
+};
+const routeBoundary = (model, event, source, host, target) => {
+    const siblings = boundariesOf(model, event.attachedTo);
+    const index = siblings.indexOf(event);
+    const start = { x: centerX(source), y: source.y + source.height };
+    const lane = start.y + 8 + 8 * (siblings.length - 1 - index);
+    const end = { x: target.x, y: centerY(target) };
+    const middle = Math.round((host.x + host.width + target.x) / 2) + 6 * index;
+    return dedupe([start, { x: start.x, y: lane }, { x: middle, y: lane }, { x: middle, y: end.y }, end]);
+};
+export const routeFlows = (model, flows, layering, boxes) => {
+    const floor = Math.max(0, ...[...boxes.values()].map((box) => box.y + box.height));
+    const routes = new Map();
+    const nodes = new Map(model.nodes.map((node) => [node.id, node]));
+    for (const flow of flows) {
+        const source = boxes.get(flow.source);
+        const target = boxes.get(flow.target);
+        const back = layering.backFlows.has(flow.id) || layering.layerOf.get(flow.target) <= layering.layerOf.get(flow.source);
+        const event = nodes.get(flow.source);
+        if (back)
+            routes.set(flow.id, routeBack(source, target, floor));
+        else if (event.attachedTo)
+            routes.set(flow.id, routeBoundary(model, event, source, boxes.get(event.attachedTo), target));
+        else
+            routes.set(flow.id, routeForward(source, target));
+    }
+    return routes;
+};
+export const placeData = (model, boxes, routes, fixed = new Map()) => {
+    const placed = new Map();
+    const open = model.data.filter((item) => !fixed.has(item.id));
+    if (open.length === 0)
+        return placed;
+    const scope = model.nodes.map((node) => boxes.get(node.id)).filter((box) => box !== undefined);
+    const left = Math.min(...scope.map((box) => box.x));
+    const top = Math.max(...scope.map((box) => box.y + box.height), ...[...routes.values()].flat().map((point) => point.y)) + DATA_GAP;
+    const wanted = open.map((item) => {
+        const link = model.associations.find((association) => association.source === item.id || association.target === item.id);
+        const other = link ? boxes.get(link.source === item.id ? link.target : link.source) : undefined;
+        return { item, x: other ? other.x + other.width / 2 - item.size.width / 2 : left };
+    });
+    wanted.sort((a, b) => a.x - b.x);
+    let cursor = -Infinity;
+    for (const { item, x } of wanted) {
+        const at = Math.max(x, cursor);
+        placed.set(item.id, { x: at, y: top, width: item.size.width, height: item.size.height });
+        cursor = at + item.size.width + DATA_SPACING;
+    }
+    return placed;
+};
+const routeAssociation = (node, data) => {
+    const nx = node.x + node.width / 2;
+    const dx = data.x + data.width / 2;
+    if (data.y >= node.y + node.height) {
+        const start = { x: nx, y: node.y + node.height };
+        const end = { x: dx, y: data.y };
+        if (nx === dx)
+            return [start, end];
+        const middle = Math.round((start.y + end.y) / 2);
+        return [start, { x: nx, y: middle }, { x: dx, y: middle }, end];
+    }
+    if (data.y + data.height <= node.y) {
+        const start = { x: nx, y: node.y };
+        const end = { x: dx, y: data.y + data.height };
+        if (nx === dx)
+            return [start, end];
+        const middle = Math.round((start.y + end.y) / 2);
+        return [start, { x: nx, y: middle }, { x: dx, y: middle }, end];
+    }
+    return [{ x: nx, y: node.y + node.height / 2 }, { x: dx, y: data.y + data.height / 2 }];
+};
+export const routeExtras = (model, boxes, only) => {
+    const routes = new Map();
+    const dataIds = new Set(model.data.map((item) => item.id));
+    for (const stub of model.stubs) {
+        if (only && !only.has(stub.id))
+            continue;
+        const source = stub.source ? boxes.get(stub.source) : undefined;
+        const target = stub.target ? boxes.get(stub.target) : undefined;
+        if (source) {
+            const y = centerY(source);
+            routes.set(stub.id, [{ x: source.x + source.width, y }, { x: source.x + source.width + STUB_LENGTH, y }]);
+        }
+        else if (target) {
+            const y = centerY(target);
+            routes.set(stub.id, [{ x: target.x - STUB_LENGTH, y }, { x: target.x, y }]);
+        }
+    }
+    for (const association of model.associations) {
+        if (only && !only.has(association.id))
+            continue;
+        const source = boxes.get(association.source);
+        const target = boxes.get(association.target);
+        if (!source || !target)
+            continue;
+        const route = dataIds.has(association.source) ? routeAssociation(target, source).reverse() : routeAssociation(source, target);
+        routes.set(association.id, route);
+    }
+    return routes;
+};
+export const measure = (model) => {
+    for (const node of model.nodes) {
+        if (node.content) {
+            measure(node.content);
+            const layering = assignLayers(node.content);
+            const origin = { x: node.content.lanes?.indent ?? 0, y: 0 };
+            const boxes = placeNodes(node.content, layering, origin);
+            node.content.lanes?.arrange(layering, boxes, origin);
+            const routes = routeFlows(node.content, node.content.flows, layering, boxes);
+            for (const [id, box] of placeData(node.content, boxes, routes))
+                boxes.set(id, box);
+            for (const [id, route] of routeExtras(node.content, boxes))
+                routes.set(id, route);
+            const points = [...routes.values()].flat();
+            const right = Math.max(0, ...[...boxes.values()].map((box) => box.x + box.width), ...points.map((point) => point.x));
+            const bottom = Math.max(0, ...[...boxes.values()].map((box) => box.y + box.height), ...points.map((point) => point.y));
+            node.size = {
+                width: Math.max(ACTIVITY_SIZE.width, right + 2 * CONTAINER_MARGIN),
+                height: Math.max(ACTIVITY_SIZE.height, bottom + 2 * CONTAINER_MARGIN),
+            };
+        }
+        node.size = { ...node.size, width: Math.max(node.size.width, boundariesOf(model, node.id).length * BOUNDARY_PITCH) };
+    }
+};
+const intersects = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+export const placeScope = (model, origin, context) => {
+    const layering = assignLayers(model);
+    const layered = placeNodes(model, layering, origin);
+    context.arrange?.(model, layering, layered, origin);
+    model.lanes?.arrange(layering, layered, origin);
+    const anchor = model.nodes.find((node) => !node.attachedTo && context.fixed.has(node.id));
+    const dx = anchor ? context.fixed.get(anchor.id).x - layered.get(anchor.id).x : 0;
+    const dy = anchor ? context.fixed.get(anchor.id).y - layered.get(anchor.id).y : 0;
+    const taken = [...(context.obstacles.get(model.id) ?? [])];
+    const boxes = new Map();
+    for (const node of model.nodes) {
+        if (node.attachedTo)
+            continue;
+        const existing = context.fixed.get(node.id);
+        if (existing) {
+            boxes.set(node.id, existing);
+            continue;
+        }
+        const base = layered.get(node.id);
+        const box = { ...base, x: base.x + dx, y: base.y + dy };
+        for (let hit = taken.filter((other) => intersects(box, other)); hit.length > 0; hit = taken.filter((other) => intersects(box, other)))
+            box.y = Math.max(...hit.map((other) => other.y + other.height)) + ROW_GAP;
+        taken.push(box);
+        boxes.set(node.id, box);
+    }
+    for (const node of model.nodes)
+        if (node.attachedTo)
+            boxes.set(node.id, context.fixed.get(node.id) ?? boundaryBox(model, node, boxes.get(node.attachedTo)));
+    const flows = context.missingFlows ? model.flows.filter((flow) => context.missingFlows.has(flow.id)) : model.flows;
+    const routed = routeFlows(model, flows, layering, boxes);
+    for (const [id, route] of routed)
+        context.routes.set(id, route);
+    const scopeRoutes = new Map(routed);
+    for (const [id, box] of placeData(model, boxes, scopeRoutes, context.fixed)) {
+        const placed = { ...box };
+        for (let hit = taken.filter((other) => intersects(placed, other)); hit.length > 0; hit = taken.filter((other) => intersects(placed, other)))
+            placed.y = Math.max(...hit.map((other) => other.y + other.height)) + ROW_GAP;
+        taken.push(placed);
+        boxes.set(id, placed);
+    }
+    for (const item of model.data)
+        if (context.fixed.has(item.id))
+            boxes.set(item.id, context.fixed.get(item.id));
+    for (const [id, route] of routeExtras(model, boxes, context.missingFlows))
+        context.routes.set(id, route);
+    for (const [id, box] of boxes)
+        context.boxes.set(id, box);
+    for (const node of model.nodes) {
+        if (!node.content)
+            continue;
+        const frame = boxes.get(node.id);
+        placeScope(node.content, { x: frame.x + CONTAINER_MARGIN + (node.content.lanes?.indent ?? 0), y: frame.y + CONTAINER_MARGIN }, context);
+        if (node.content.lanes && context.lanes) {
+            const inner = { x: frame.x + CONTAINER_MARGIN, y: frame.y + CONTAINER_MARGIN, width: frame.width - 2 * CONTAINER_MARGIN, height: frame.height - 2 * CONTAINER_MARGIN };
+            const anchored = node.content.nodes.some((child) => context.fixed.has(child.id));
+            for (const [id, box] of node.content.lanes.boxes(inner, context.boxes, anchored))
+                context.lanes.set(id, box);
+        }
+    }
+};
+export const place = (model) => {
+    measure(model);
+    const context = { fixed: new Map(), obstacles: new Map(), boxes: new Map(), routes: new Map() };
+    placeScope(model, ORIGIN, context);
+    return context;
+};

package/dist/layout/standalone.d.ts

@@ -0,0 +1,8 @@
+import { type LaneNode } from "./lanes.ts";
+import { type Box, type Placement, type ProcessModel } from "./model.ts";
+export interface StandaloneExisting {
+    fixed: Map<string, Box>;
+    obstacles: Map<string, Box[]>;
+    missingFlows?: Set<string>;
+}
+export declare const placeStandalone: (model: ProcessModel, lanes: LaneNode[] | undefined, existing?: StandaloneExisting) => Required<Placement>;

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[];