@bpmnkit/editor 0.0.8

package/dist/element-groups.d.ts

@@ -0,0 +1,14 @@
+import type { CreateShapeType, LabelPosition } from "./types.js";
+export interface ElementGroup {
+    id: string;
+    title: string;
+    defaultType: CreateShapeType;
+    types: ReadonlyArray<CreateShapeType>;
+}
+export declare const ELEMENT_GROUPS: ReadonlyArray<ElementGroup>;
+export declare function getElementGroup(type: CreateShapeType): ElementGroup | undefined;
+export declare const ELEMENT_TYPE_LABELS: Readonly<Record<CreateShapeType, string>>;
+export declare const EXTERNAL_LABEL_TYPES: ReadonlySet<CreateShapeType>;
+export declare const CONTEXTUAL_ADD_TYPES: ReadonlyArray<CreateShapeType>;
+export declare function getValidLabelPositions(type: CreateShapeType): ReadonlyArray<LabelPosition>;
+//# sourceMappingURL=element-groups.d.ts.map

package/dist/element-groups.js

@@ -0,0 +1,195 @@
+export const ELEMENT_GROUPS = [
+    {
+        id: "startEvents",
+        title: "Start Events",
+        defaultType: "startEvent",
+        types: [
+            "startEvent",
+            "messageStartEvent",
+            "timerStartEvent",
+            "conditionalStartEvent",
+            "signalStartEvent",
+        ],
+    },
+    {
+        id: "endEvents",
+        title: "End Events",
+        defaultType: "endEvent",
+        types: [
+            "endEvent",
+            "messageEndEvent",
+            "escalationEndEvent",
+            "errorEndEvent",
+            "compensationEndEvent",
+            "signalEndEvent",
+            "terminateEndEvent",
+        ],
+    },
+    {
+        id: "intermediateEvents",
+        title: "Intermediate Events",
+        defaultType: "messageCatchEvent",
+        types: [
+            "messageCatchEvent",
+            "messageThrowEvent",
+            "timerCatchEvent",
+            "escalationThrowEvent",
+            "conditionalCatchEvent",
+            "linkCatchEvent",
+            "linkThrowEvent",
+            "compensationThrowEvent",
+            "signalCatchEvent",
+            "signalThrowEvent",
+        ],
+    },
+    {
+        id: "activities",
+        title: "Activities",
+        defaultType: "serviceTask",
+        types: [
+            "task",
+            "serviceTask",
+            "userTask",
+            "scriptTask",
+            "sendTask",
+            "receiveTask",
+            "businessRuleTask",
+            "manualTask",
+            "callActivity",
+            "subProcess",
+            "adHocSubProcess",
+            "transaction",
+        ],
+    },
+    {
+        id: "gateways",
+        title: "Gateways",
+        defaultType: "exclusiveGateway",
+        types: [
+            "exclusiveGateway",
+            "parallelGateway",
+            "inclusiveGateway",
+            "eventBasedGateway",
+            "complexGateway",
+        ],
+    },
+    {
+        id: "annotations",
+        title: "Annotations",
+        defaultType: "textAnnotation",
+        types: ["textAnnotation"],
+    },
+];
+const _typeToGroup = new Map();
+for (const group of ELEMENT_GROUPS) {
+    for (const type of group.types) {
+        _typeToGroup.set(type, group);
+    }
+}
+export function getElementGroup(type) {
+    return _typeToGroup.get(type);
+}
+export const ELEMENT_TYPE_LABELS = {
+    startEvent: "Start Event",
+    messageStartEvent: "Message Start Event",
+    timerStartEvent: "Timer Start Event",
+    conditionalStartEvent: "Conditional Start Event",
+    signalStartEvent: "Signal Start Event",
+    endEvent: "End Event",
+    messageEndEvent: "Message End Event",
+    escalationEndEvent: "Escalation End Event",
+    errorEndEvent: "Error End Event",
+    compensationEndEvent: "Compensation End Event",
+    signalEndEvent: "Signal End Event",
+    terminateEndEvent: "Terminate End Event",
+    intermediateThrowEvent: "Intermediate Throw Event",
+    intermediateCatchEvent: "Intermediate Catch Event",
+    messageCatchEvent: "Message Intermediate Catch Event",
+    messageThrowEvent: "Message Intermediate Throw Event",
+    timerCatchEvent: "Timer Intermediate Catch Event",
+    escalationThrowEvent: "Escalation Intermediate Throw Event",
+    conditionalCatchEvent: "Conditional Intermediate Catch Event",
+    linkCatchEvent: "Link Intermediate Catch Event",
+    linkThrowEvent: "Link Intermediate Throw Event",
+    compensationThrowEvent: "Compensation Intermediate Throw Event",
+    signalCatchEvent: "Signal Intermediate Catch Event",
+    signalThrowEvent: "Signal Intermediate Throw Event",
+    task: "Task",
+    serviceTask: "Service Task",
+    userTask: "User Task",
+    scriptTask: "Script Task",
+    sendTask: "Send Task",
+    receiveTask: "Receive Task",
+    businessRuleTask: "Business Rule Task",
+    manualTask: "Manual Task",
+    callActivity: "Call Activity",
+    subProcess: "Sub-Process",
+    adHocSubProcess: "Ad-hoc Sub-Process",
+    transaction: "Transaction",
+    exclusiveGateway: "Exclusive Gateway",
+    parallelGateway: "Parallel Gateway",
+    inclusiveGateway: "Inclusive Gateway",
+    eventBasedGateway: "Event-based Gateway",
+    complexGateway: "Complex Gateway",
+    textAnnotation: "Text Annotation",
+};
+export const EXTERNAL_LABEL_TYPES = new Set([
+    "startEvent",
+    "messageStartEvent",
+    "timerStartEvent",
+    "conditionalStartEvent",
+    "signalStartEvent",
+    "endEvent",
+    "messageEndEvent",
+    "escalationEndEvent",
+    "errorEndEvent",
+    "compensationEndEvent",
+    "signalEndEvent",
+    "terminateEndEvent",
+    "intermediateThrowEvent",
+    "intermediateCatchEvent",
+    "messageCatchEvent",
+    "messageThrowEvent",
+    "timerCatchEvent",
+    "escalationThrowEvent",
+    "conditionalCatchEvent",
+    "linkCatchEvent",
+    "linkThrowEvent",
+    "compensationThrowEvent",
+    "signalCatchEvent",
+    "signalThrowEvent",
+    "exclusiveGateway",
+    "parallelGateway",
+    "inclusiveGateway",
+    "eventBasedGateway",
+    "complexGateway",
+]);
+export const CONTEXTUAL_ADD_TYPES = [
+    "serviceTask",
+    "exclusiveGateway",
+    "endEvent",
+];
+export function getValidLabelPositions(type) {
+    const base = ["bottom", "top", "left", "right"];
+    if (type === "exclusiveGateway" ||
+        type === "parallelGateway" ||
+        type === "inclusiveGateway" ||
+        type === "eventBasedGateway" ||
+        type === "complexGateway" ||
+        type === "intermediateThrowEvent" ||
+        type === "intermediateCatchEvent" ||
+        type === "messageCatchEvent" ||
+        type === "messageThrowEvent" ||
+        type === "timerCatchEvent" ||
+        type === "escalationThrowEvent" ||
+        type === "conditionalCatchEvent" ||
+        type === "linkCatchEvent" ||
+        type === "linkThrowEvent" ||
+        type === "compensationThrowEvent" ||
+        type === "signalCatchEvent" ||
+        type === "signalThrowEvent") {
+        return [...base, "bottom-left", "bottom-right", "top-left", "top-right"];
+    }
+    return base;
+}
+//# sourceMappingURL=element-groups.js.map

package/dist/geometry.d.ts

@@ -0,0 +1,89 @@
+import type { RenderedShape, ViewportState } from "@bpmnkit/canvas";
+import type { BpmnBounds, BpmnWaypoint } from "@bpmnkit/core";
+import type { DiagPoint, HandleDir, LabelPosition, PortDir } from "./types.js";
+/**
+ * Converts client (screen) coordinates to diagram coordinates accounting for
+ * the current viewport transform.
+ */
+export declare function screenToDiagram(screenX: number, screenY: number, viewport: ViewportState, svgRect: DOMRect): DiagPoint;
+/**
+ * Converts diagram coordinates to client (screen) coordinates.
+ */
+export declare function diagramToScreen(diagX: number, diagY: number, viewport: ViewportState, svgRect: DOMRect): {
+    x: number;
+    y: number;
+};
+/**
+ * Returns the topmost shape that contains the diagram-space point (x, y),
+ * or null if none. Iterates in reverse render order (last = top).
+ */
+export declare function hitTestShape(shapes: RenderedShape[], x: number, y: number): RenderedShape | null;
+/** Returns the 8 handle positions (diagram space) for a shape's bounding box. */
+export declare function handlePositions(bounds: BpmnBounds): Record<HandleDir, DiagPoint>;
+/** Returns the 4 connection port positions (diagram space) for a shape. */
+export declare function portPositions(bounds: BpmnBounds): Array<{
+    x: number;
+    y: number;
+    dir: PortDir;
+}>;
+/**
+ * Applies a resize handle drag to produce new bounds.
+ * `diagX` and `diagY` are the current cursor position in diagram space.
+ */
+export declare function applyResize(original: BpmnBounds, handle: HandleDir, diagX: number, diagY: number): BpmnBounds;
+/**
+ * Computes orthogonal (H/V only) waypoints between two shapes.
+ * Picks exit/entry ports based on relative position: prefers L-shaped (one-bend) routes
+ * over Z-shaped (two-bend) routes. For gateways or events below/above the source,
+ * uses the bottom/top port rather than always exiting right.
+ */
+export declare function computeWaypoints(src: BpmnBounds, tgt: BpmnBounds): BpmnWaypoint[];
+/**
+ * Computes the absolute diagram-space bounds for an external label given a
+ * position option and the shape it belongs to.
+ */
+export declare function labelBoundsForPosition(shape: BpmnBounds, position: LabelPosition): BpmnBounds;
+/** Returns the midpoint of a specific port edge in diagram space. */
+export declare function portPoint(bounds: BpmnBounds, port: PortDir): DiagPoint;
+/** Returns which port of `bounds` is nearest to `pos` in diagram space. */
+export declare function closestPort(pos: DiagPoint, bounds: BpmnBounds): PortDir;
+/**
+ * Derives which port of `bounds` a waypoint exits from / enters at.
+ * Uses the dominant axis between the waypoint and the shape centre.
+ */
+export declare function portFromWaypoint(wp: BpmnWaypoint, bounds: BpmnBounds): PortDir;
+/**
+ * Computes orthogonal waypoints connecting two shapes via explicit exit/entry
+ * ports.  All segments are horizontal or vertical.
+ */
+/**
+ * Routes orthogonal waypoints between two explicit points given their exit/entry directions.
+ * All segments are horizontal or vertical.
+ */
+export declare function routeOrthogonal(E: DiagPoint, srcPort: PortDir, P: DiagPoint, tgtPort: PortDir): BpmnWaypoint[];
+export declare function computeWaypointsWithPorts(src: BpmnBounds, srcPort: PortDir, tgt: BpmnBounds, tgtPort: PortDir): BpmnWaypoint[];
+export declare function waypointsIntersectObstacles(wps: BpmnWaypoint[], obstacles: BpmnBounds[]): boolean;
+/**
+ * Returns true if any intermediate waypoint (not the first or last) lies strictly
+ * inside the shape's bounding box.  This catches routes that enter the source or
+ * target shape's interior before reaching the connection point — a situation that
+ * waypointsIntersectObstacles cannot detect because src/tgt are excluded from the
+ * obstacles list.
+ */
+export declare function routeEntersShape(wps: BpmnWaypoint[], shape: BpmnBounds): boolean;
+/**
+ * Computes waypoints between two shapes, routing around obstacle shapes and
+ * never passing through the source or target shape's own interior.
+ *
+ * Strategy:
+ *  1. Try the default (most natural) route.
+ *  2. Try all 16 port-pair combinations in natural-first order.
+ *  3. Try explicit bypass corridors above/below/left/right of each obstacle.
+ *  4. Fall back to the default route as an absolute last resort.
+ */
+export declare function computeWaypointsAvoiding(src: BpmnBounds, tgt: BpmnBounds, obstacles: BpmnBounds[]): BpmnWaypoint[];
+/**
+ * Returns the bounding box that encloses all selected shapes, or null if none.
+ */
+export declare function selectionBounds(shapes: RenderedShape[], ids: string[]): BpmnBounds | null;
+//# sourceMappingURL=geometry.d.ts.map