@formicoidea/labre-framework-bpmn 0.59.0 → 0.60.0

package/dist/actions.js

@@ -7,12 +7,12 @@ import { downloadBlob } from '@formicoidea/labre-core/shared/utils';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { GfxControllerIdentifier, GfxGroupLikeElementModel, } from '@formicoidea/labre-core/std/gfx';
 import { BPMN_POOL_BACKGROUND } from './background.js';
-import { BPMN_EDGE_STYLE, bpmnLabelMode, LANE_NAME_FALLBACK, LANE_NAME_KEY, NODE_LABEL, nodeLabelKey, NODE_SIZE, POOL_NAME_FALLBACK, POOL_NAME_KEY, } from './consts.js';
+import { BPMN_EDGE_STYLE, LANE_NAME_FALLBACK, LANE_NAME_KEY, NODE_LABEL, nodeLabelKey, NODE_SIZE, POOL_NAME_FALLBACK, POOL_NAME_KEY, POOL_REF_HEIGHT, POOL_REF_WIDTH, } from './consts.js';
 import { BPMN_FORMAT_ID, exportBpmnXmlWithWarnings, } from './export.js';
 import { bpmnLaneOf } from './facts.js';
 import { BPMN_SVG_IMPORT, BPMN_XML_EXPORT, BPMN_XML_FORMAT, BPMN_XML_IMPORT, bpmnBoardFrom, bpmnSafeFilename, } from './interchange.js';
-import { bpmnLabelBoxFor, bpmnLabelProps, bpmnNodeProps, bpmnPoolProps, } from './presets.js';
 import { BPMN_ROLE } from './roles.js';
+import { bpmnNodeElements, bpmnPoolElement } from './toolbox.js';
 /**
  * Standalone creation/activation actions for the BPMN toolbox — lifted out of
  * `toolbar/bpmn-menu.ts` by PF3 so the menu becomes a pure renderer over the
@@ -54,30 +54,29 @@ export function createBpmnNode(std, kind) {
         return;
     const { w, h } = NODE_SIZE[kind];
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    // Translated HERE and once: the caption is document content the moment it
-    // lands, so the host's catalogue is asked at placement and never again
-    // (`nodeLabelKey`, and #183 on why a French board should not start in
-    // English).
-    const seed = NODE_LABEL[kind]
-        ? translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind])
-        : undefined;
-    const external = bpmnLabelMode(kind) === 'external';
-    // What a node IS lives in one place (`./presets.ts`), because the importer
-    // creates the same artefacts out of a `.bpmn` file and the two must not
-    // drift: a task read from a file and a task drawn here are one element type
-    // in the document, down to the stroke width. The gesture owns the BOX and
-    // nothing else.
-    const id = surface.addElement(bpmnNodeProps(kind, {
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        text: external ? undefined : seed,
-    }));
-    if (!external || seed === undefined) {
-        finish(gfx, id);
-        return;
+    // The elements come from the ONE assembly a host with no editor also calls
+    // (`toolbox.ts`, `docs/adr/0045`), on the presets the importer reads too
+    // (`presets.ts`): a task drawn here, one read from a `.bpmn` file and one a
+    // host places are one element type in the document, down to the stroke
+    // width. What only an editor has stays here: the viewport centre, and the
+    // caption translated HERE and once (`nodeLabelKey`, and #183 on why a French
+    // board should not start in English).
+    const elements = bpmnNodeElements(kind, { x: cx - w / 2, y: cy - h / 2 }, { name: translateKey(std, nodeLabelKey(kind), NODE_LABEL[kind]) });
+    const minted = new Map();
+    for (const { id: local, ...props } of elements) {
+        if (props.type === 'group') {
+            // Through the native group command and not `addElement`: the group's
+            // seed title is numbered against the groups already on the board, and
+            // its user layer is its highest member's (ADR 0031) — both the editor's.
+            const children = Object.keys(props.children);
+            finish(gfx, group(gfx, children.map(child => minted.get(child) ?? child)));
+            return;
+        }
+        minted.set(local, surface.addElement(props));
     }
-    const { x, y } = bpmnLabelBoxFor(kind, cx, cy);
-    const labelId = surface.addElement(bpmnLabelProps(seed, x, y));
-    finish(gfx, group(gfx, [id, labelId]));
+    const id = minted.get(`${kind}:node`);
+    if (id)
+        finish(gfx, id);
 }
 /** Create a pool (background container) centred on the viewport. */
 export function createBpmnPool(std) {
@@ -85,24 +84,20 @@ export function createBpmnPool(std) {
     const surface = gfx.surface;
     if (!surface)
         return;
-    const w = 560;
-    const h = 200;
     const { centerX: cx, centerY: cy } = gfx.viewport;
-    // What a pool IS lives in one place (`./presets.ts`), beside what a node is
-    // and for the same reason: the shipped cards build their participants from it
-    // too, so a pool laid out by a template and one dropped from the toolbox
-    // cannot say different things. The gesture owns the BOX and nothing else.
+    // What a pool IS lives in one place (`bpmnPoolElement`, `toolbox.ts`, over
+    // `bpmnPoolProps`), beside what a node is and for the same reason: the
+    // shipped cards and a host build their participants from it too, so a pool
+    // laid out by a template, one a host places and one dropped from the toolbox
+    // cannot say different things. The gesture owns the centre and nothing else.
     //
     // The NAME is the one exception, and it is written HERE rather than left to
     // the model's default (`BpmnPoolElementModel.name = 'Pool'`, a red-zone
     // field: a document created before this key existed keeps its literal
     // 'Pool' verbatim). Resolved at placement and never again — content from
     // the moment it lands, exactly like a node's caption.
-    const id = surface.addElement(bpmnPoolProps({
-        xywh: new Bound(cx - w / 2, cy - h / 2, w, h).serialize(),
-        name: translateKey(std, POOL_NAME_KEY, POOL_NAME_FALLBACK),
-    }));
-    finish(gfx, id);
+    const { id: _local, ...props } = bpmnPoolElement({ x: cx - POOL_REF_WIDTH / 2, y: cy - POOL_REF_HEIGHT / 2 }, { name: translateKey(std, POOL_NAME_KEY, POOL_NAME_FALLBACK) });
+    finish(gfx, surface.addElement(props));
 }
 /**
  * Arm the native connector tool, pre-styled for a BPMN sequence flow:

package/dist/consts.d.ts

@@ -268,8 +268,8 @@ export declare const POOL_LANE_MIN_HEIGHT = 24;
  * participant, and a second lane that matched the first one's height would
  * claim room the process has not asked for.
  *
- * `actions.ts` and the templates still write these two numbers themselves; the
- * declaration names them so there is somewhere for them to converge.
+ * The toolbox draws its pool at them (`bpmnPoolElement`, which `createBpmnPool`
+ * calls); the templates lay their pools out at sizes of their own.
  */
 export declare const POOL_REF_WIDTH = 560;
 export declare const POOL_REF_HEIGHT = 200;

package/dist/consts.js

@@ -329,8 +329,8 @@ export const POOL_LANE_MIN_HEIGHT = 24;
  * participant, and a second lane that matched the first one's height would
  * claim room the process has not asked for.
  *
- * `actions.ts` and the templates still write these two numbers themselves; the
- * declaration names them so there is somewhere for them to converge.
+ * The toolbox draws its pool at them (`bpmnPoolElement`, which `createBpmnPool`
+ * calls); the templates lay their pools out at sizes of their own.
  */
 export const POOL_REF_WIDTH = 560;
 export const POOL_REF_HEIGHT = 200;

package/dist/import.js

@@ -1,9 +1,8 @@
 import { InterchangeImportError, readXmlElement, } from '@formicoidea/labre-core/interchange';
-import { ConnectorMode, PointStyle, StrokeStyle, } from '@formicoidea/labre-core/model/headless';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { ASSOCIATION_STROKE, ASSOCIATION_WIDTH, bpmnLabelMode, MESSAGE_STROKE, MESSAGE_WIDTH, NODE_SIZE, POOL_BAND_WIDTH, POOL_REF_HEIGHT, POOL_REF_WIDTH, SEQUENCE_STROKE, SEQUENCE_WIDTH, } from './consts.js';
+import { bpmnLabelMode, NODE_SIZE, POOL_BAND_WIDTH, POOL_REF_HEIGHT, POOL_REF_WIDTH, } from './consts.js';
 import { BPMN_FORMAT_ID, BPMN_NS, BPMN_OWN_DECLARATIONS, BPMN_SCOPE, BPMN_XML_OF_KIND, escapeAttr, escapeText, } from './export.js';
-import { bpmnLabelBoxUnder, bpmnLabelProps, bpmnNodeProps } from './presets.js';
+import { bpmnConnectorProps, bpmnLabelBoxUnder, bpmnLabelProps, bpmnNodeProps, } from './presets.js';
 import { BPMN_ROLE } from './roles.js';
 /**
  * The remarks whose wording is FIXED, as `[key, English]` pairs — one entry
@@ -637,39 +636,18 @@ const SWEEP_STEP = 200;
 const SWEEP_COLUMNS = 4;
 /** The margin between a minted pool's plot and the work inside it. */
 const MINTED_POOL_PADDING = 40;
-/** The connector a role is drawn as — the styles the tools arm, one table. */
+/**
+ * The connector a role is drawn as — the styles the tools arm, one table
+ * (`bpmnConnectorProps`). A role this reader does not know keeps its own name
+ * and takes the sequence flow's line.
+ */
 function connectorProps(role) {
-    const base = { type: 'connector', role, mode: ConnectorMode.Orthogonal };
-    if (role === BPMN_ROLE.messageFlow) {
-        return {
-            ...base,
-            stroke: MESSAGE_STROKE,
-            strokeWidth: MESSAGE_WIDTH,
-            strokeStyle: StrokeStyle.Dash,
-            frontEndpointStyle: PointStyle.Circle,
-            rearEndpointStyle: PointStyle.Arrow,
-        };
-    }
-    if (role === BPMN_ROLE.association) {
-        return {
-            ...base,
-            stroke: ASSOCIATION_STROKE,
-            strokeWidth: ASSOCIATION_WIDTH,
-            strokeStyle: StrokeStyle.Dash,
-            // No head at either end: an association claims no direction, and an
-            // arrowhead would be the picture claiming one (`docs/adr/0010`).
-            frontEndpointStyle: PointStyle.None,
-            rearEndpointStyle: PointStyle.None,
-        };
-    }
-    return {
-        ...base,
-        stroke: SEQUENCE_STROKE,
-        strokeWidth: SEQUENCE_WIDTH,
-        strokeStyle: StrokeStyle.Solid,
-        frontEndpointStyle: PointStyle.None,
-        rearEndpointStyle: PointStyle.Triangle,
-    };
+    const edge = role === BPMN_ROLE.messageFlow
+        ? 'messageFlow'
+        : role === BPMN_ROLE.association
+            ? 'association'
+            : 'sequenceFlow';
+    return { ...bpmnConnectorProps(edge), role };
 }
 /**
  * The version of the format this file declares (ADR 0012, P2 as amended).

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { bpmnCommandIcons, bpmnCommands } from './commands.js';
 export { BPMN_FORMAT_ID, BPMN_NS, BPMN_XML_OF_KIND, type BpmnExportBoard, type BpmnExportOptions, type BpmnExportOutcome, type BpmnXmlMapping, exportBpmnXml, exportBpmnXmlWithWarnings, isNcName, toNcName, } from './export.js';
 export { BPMN_KIND_OF_XML, BPMN_QUARANTINE_REASON, importBpmnXml, } from './import.js';
 export { bpmnLabelFit, type BpmnLabelFit, bpmnMorphClears, bpmnMorphProps, bpmnNodeProps, type BpmnNodePreset, NODE_PRESETS, } from './presets.js';
+export { BPMN_TOOLBOX, bpmnFlowElement, bpmnNodeElements, type BpmnNodeTexts, bpmnPoolElement, type BpmnPoolTexts, } from './toolbox.js';
 export { BPMN_MORPH_FAMILIES, BPMN_MORPH_SPEC } from './morph.js';
 export { BPMN_INTERCHANGE, BPMN_SVG_FORMAT, BPMN_SVG_IMPORT, BPMN_XML_EXPORT, BPMN_XML_EXTENSION, BPMN_XML_IMPORT, BPMN_XML_FORMAT, BPMN_XML_MIME, bpmnBoardFrom, bpmnSafeFilename, } from './interchange.js';
 export { bpmnLaneOf, bpmnPoolOf } from './facts.js';

package/dist/index.js

@@ -30,6 +30,8 @@ export { BPMN_KIND_OF_XML, BPMN_QUARANTINE_REASON, importBpmnXml, } from './impo
 // geometry of its own — a file, a generator, another editor's board — fits their
 // labels the way the importer does, rather than reinventing the arithmetic.
 export { bpmnLabelFit, bpmnMorphClears, bpmnMorphProps, bpmnNodeProps, NODE_PRESETS, } from './presets.js';
+// The toolbar as pure builders (`docs/adr/0045`), also on `./interchange`.
+export { BPMN_TOOLBOX, bpmnFlowElement, bpmnNodeElements, bpmnPoolElement, } from './toolbox.js';
 // What an artefact may BECOME: the declared families, and the spec the generic
 // morph module is registered with. Data a host can read without an editor.
 export { BPMN_MORPH_FAMILIES, BPMN_MORPH_SPEC } from './morph.js';

package/dist/interchange-headless.d.ts

@@ -72,3 +72,4 @@ export declare const BPMN_SVG_FORMAT: InterchangeFormat;
  * would be a re-render (P2).
  */
 export declare const BPMN_SVG_IMPORT: InterchangeImportCapability;
+export { BPMN_TOOLBOX, bpmnFlowElement, bpmnNodeElements, type BpmnNodeTexts, bpmnPoolElement, type BpmnPoolTexts, } from './toolbox.js';

package/dist/interchange-headless.js

@@ -98,3 +98,6 @@ export const BPMN_SVG_IMPORT = {
     direction: 'import',
     run: parseSvgSketch,
 };
+// The toolbar as pure builders (`docs/adr/0045`): what a host with no editor
+// places to draw the very elements a user places from the toolbar.
+export { BPMN_TOOLBOX, bpmnFlowElement, bpmnNodeElements, bpmnPoolElement, } from './toolbox.js';

package/dist/presets.d.ts

@@ -1,5 +1,6 @@
 import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
 import { StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign } from '@formicoidea/labre-core/model/headless';
+import { type BpmnEdgeKey } from './consts.js';
 /**
  * What a BPMN artefact is BORN as — the one description of a node's props, read
  * by every site that creates one.
@@ -174,6 +175,17 @@ export declare function bpmnPoolProps(box: {
 }): Record<string, unknown> & {
     type: string;
 };
+/**
+ * One BPMN connecting object, as the props `surface.addElement` takes, ends
+ * left to the caller: the role, the orthogonal mode the tools arm the
+ * connector with, and the line {@link BPMN_EDGE_STYLE} says it looks like.
+ *
+ * The importer and the toolbox both write a flow through here, so a flow read
+ * out of a `.bpmn` file and one a host places are the line the tool draws.
+ */
+export declare function bpmnConnectorProps(edge: BpmnEdgeKey): Record<string, unknown> & {
+    type: string;
+};
 /**
  * What a node's kind is worth to an element that ALREADY EXISTS — the same
  * description as {@link bpmnNodeProps}, minus the three things a morph has no

package/dist/presets.js

@@ -1,6 +1,6 @@
-import { FontFamily, SHAPE_TEXT_PADDING, SHAPE_TEXT_VERTICAL_PADDING, ShapeStyle, StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign, } from '@formicoidea/labre-core/model/headless';
+import { ConnectorMode, FontFamily, SHAPE_TEXT_PADDING, SHAPE_TEXT_VERTICAL_PADDING, ShapeStyle, StrokeStyle, TextAlign, TextFitMode, TextVerticalAlign, } from '@formicoidea/labre-core/model/headless';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
-import { ACTIVITY_FIT_REF, BPMN_LABEL_GAP, BPMN_LABEL_H, BPMN_LABEL_W, CALL_ACTIVITY_WIDTH, END_WIDTH, EVENT_END, EVENT_START, GROUP_RADIUS, GROUP_STROKE, INNER_FONT_SIZE, isBpmnActivityKind, LABEL_FONT_SIZE, LABEL_INSET_RATIO, LABEL_MIN_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_SIZE, NODE_STROKE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
+import { ACTIVITY_FIT_REF, BPMN_EDGE_STYLE, BPMN_LABEL_GAP, BPMN_LABEL_H, BPMN_LABEL_W, CALL_ACTIVITY_WIDTH, END_WIDTH, EVENT_END, EVENT_START, GROUP_RADIUS, GROUP_STROKE, INNER_FONT_SIZE, isBpmnActivityKind, LABEL_FONT_SIZE, LABEL_INSET_RATIO, LABEL_MIN_FONT_SIZE, NEUTRAL_STROKE, NODE_FILL, NODE_SIZE, NODE_STROKE_WIDTH, START_WIDTH, TASK_RADIUS, } from './consts.js';
 import { BPMN_ROLE, BPMN_ROLE_OF_KIND } from './roles.js';
 /** Per-kind native shape + accent presets (style C). */
 export const NODE_PRESETS = {
@@ -320,6 +320,22 @@ export function bpmnPoolProps(box) {
         xywh: box.xywh,
     };
 }
+/**
+ * One BPMN connecting object, as the props `surface.addElement` takes, ends
+ * left to the caller: the role, the orthogonal mode the tools arm the
+ * connector with, and the line {@link BPMN_EDGE_STYLE} says it looks like.
+ *
+ * The importer and the toolbox both write a flow through here, so a flow read
+ * out of a `.bpmn` file and one a host places are the line the tool draws.
+ */
+export function bpmnConnectorProps(edge) {
+    return {
+        type: 'connector',
+        role: BPMN_ROLE[edge],
+        mode: ConnectorMode.Orthogonal,
+        ...BPMN_EDGE_STYLE[edge],
+    };
+}
 /**
  * The box {@link bpmnMorphProps} hands {@link bpmnNodeProps} and then throws
  * away. Never written to a document: a morph keeps the geometry the element

package/dist/toolbox.d.ts

@@ -0,0 +1,45 @@
+import type { FrameworkToolbox, SerializedElementProps, ToolboxPoint } from '@formicoidea/labre-core/interchange';
+import type { BpmnNodeKind } from '@formicoidea/labre-core/model';
+import { type BpmnEdgeKey } from './consts.js';
+/**
+ * BPMN's toolbar as pure builders (`docs/adr/0045`): what `createBpmnNode`,
+ * `createBpmnPool`, the lane gesture and the three flow tools place, with no
+ * editor behind them. The actions call these, so an artefact a host places
+ * and one placed from the toolbar are the same elements.
+ */
+/** The text slot of a flow object, an artefact or a data shape. */
+export interface BpmnNodeTexts {
+    /** The name; the kind's English seed when absent. */
+    name?: string;
+}
+/**
+ * A BPMN artefact at `at` (its top-left), as the toolbar places it.
+ *
+ * An inscribed kind (activities, the annotation, the group) is ONE element
+ * carrying its name inside. An external kind (events, gateways, data shapes)
+ * is the bare symbol, its name as a `bpmn:label` text centred under it, and
+ * the group that makes the two one artefact, last (R38). The symbol's id is
+ * `<local>:node` either way, which is what a flow attaches to.
+ */
+export declare function bpmnNodeElements(kind: BpmnNodeKind, at: ToolboxPoint, texts?: BpmnNodeTexts, local?: string): SerializedElementProps[];
+/** The text slots of a pool. */
+export interface BpmnPoolTexts {
+    /** The participant's name; `Pool` when absent. */
+    name?: string;
+    /** One lane name per line, top to bottom; no lane when absent. */
+    lanes?: string;
+}
+/**
+ * A pool at `at`, at the size the toolbar draws it, with the lanes it is
+ * given.
+ *
+ * Each lane is what one click on "Add lane" appends to a fresh pool: an equal
+ * weight of 1, and `Lane N` when its line is blank. Its id is `<local>-lane-N`
+ * and not a minted one: a builder mints nothing, and an id unique within the
+ * pool is all a lane needs (the importer's own `lane-N` fallback).
+ */
+export declare function bpmnPoolElement(at: ToolboxPoint, texts?: BpmnPoolTexts, local?: string): SerializedElementProps;
+/** The connector a flow tool is armed with, between two ends. */
+export declare function bpmnFlowElement(edge: BpmnEdgeKey, from: string, to: string, label?: string): SerializedElementProps;
+/** Every item of the BPMN toolbar that places elements, in the toolbar's order. */
+export declare const BPMN_TOOLBOX: FrameworkToolbox;

package/dist/toolbox.js

@@ -0,0 +1,129 @@
+import { Bound } from '@formicoidea/labre-core/global/gfx';
+import { bpmnCommandsManifest } from './commands-manifest.js';
+import { bpmnLabelMode, LANE_NAME_FALLBACK, NODE_LABEL, NODE_SIZE, POOL_NAME_FALLBACK, POOL_REF_HEIGHT, POOL_REF_WIDTH, } from './consts.js';
+import { bpmnConnectorProps, bpmnLabelBoxFor, bpmnLabelProps, bpmnNodeProps, bpmnPoolProps, } from './presets.js';
+/**
+ * A BPMN artefact at `at` (its top-left), as the toolbar places it.
+ *
+ * An inscribed kind (activities, the annotation, the group) is ONE element
+ * carrying its name inside. An external kind (events, gateways, data shapes)
+ * is the bare symbol, its name as a `bpmn:label` text centred under it, and
+ * the group that makes the two one artefact, last (R38). The symbol's id is
+ * `<local>:node` either way, which is what a flow attaches to.
+ */
+export function bpmnNodeElements(kind, at, texts = {}, local = kind) {
+    const { w, h } = NODE_SIZE[kind];
+    const name = texts.name?.trim() || NODE_LABEL[kind];
+    const id = (part) => `${local}:${part}`;
+    const xywh = new Bound(at.x, at.y, w, h).serialize();
+    if (bpmnLabelMode(kind) === 'inscribed') {
+        return [{ ...bpmnNodeProps(kind, { xywh, text: name }), id: id('node') }];
+    }
+    const label = bpmnLabelBoxFor(kind, at.x + w / 2, at.y + h / 2);
+    const members = [
+        // `text: undefined` and not no key: the symbol is born bare exactly as the
+        // toolbar's is, and `bpmnNodeProps` passes the key through unchanged.
+        { ...bpmnNodeProps(kind, { xywh, text: undefined }), id: id('node') },
+        { ...bpmnLabelProps(name, label.x, label.y), id: id('label') },
+    ];
+    return [
+        ...members,
+        {
+            type: 'group',
+            id: id('group'),
+            children: Object.fromEntries(members.map(m => [m.id, true])),
+        },
+    ];
+}
+/**
+ * A pool at `at`, at the size the toolbar draws it, with the lanes it is
+ * given.
+ *
+ * Each lane is what one click on "Add lane" appends to a fresh pool: an equal
+ * weight of 1, and `Lane N` when its line is blank. Its id is `<local>-lane-N`
+ * and not a minted one: a builder mints nothing, and an id unique within the
+ * pool is all a lane needs (the importer's own `lane-N` fallback).
+ */
+export function bpmnPoolElement(at, texts = {}, local = 'pool') {
+    const names = (texts.lanes ?? '').split('\n').map(line => line.trim());
+    const lanes = texts.lanes?.trim()
+        ? names.map((name, i) => ({
+            id: `${local}-lane-${i + 1}`,
+            name: name || LANE_NAME_FALLBACK.replace('{{n}}', String(i + 1)),
+            size: 1,
+        }))
+        : [];
+    return {
+        ...bpmnPoolProps({
+            xywh: new Bound(at.x, at.y, POOL_REF_WIDTH, POOL_REF_HEIGHT).serialize(),
+            name: texts.name?.trim() || POOL_NAME_FALLBACK,
+        }),
+        id: local,
+        // Absent until the first lane, as on a pool drawn from the toolbar.
+        ...(lanes.length > 0 ? { lanes } : {}),
+    };
+}
+/** The connector a flow tool is armed with, between two ends. */
+export function bpmnFlowElement(edge, from, to, label) {
+    return {
+        ...bpmnConnectorProps(edge),
+        source: { id: from },
+        target: { id: to },
+        ...(label?.trim() ? { text: label.trim() } : {}),
+    };
+}
+/** The toolbar command's label, so a host names an item as the toolbar does. */
+function label(commandId) {
+    const row = bpmnCommandsManifest.find(r => r.id === commandId);
+    return {
+        labelKey: row?.labelKey ?? commandId,
+        labelFallback: row?.labelFallback ?? commandId,
+    };
+}
+const nodeItem = (id, kind, commandId) => ({
+    id,
+    ...label(commandId),
+    texts: ['name'],
+    size: NODE_SIZE[kind],
+    build: (at, texts, local) => bpmnNodeElements(kind, at, texts, local),
+});
+const flowLink = (id, edge, commandId) => ({
+    id,
+    ...label(commandId),
+    build: (from, to, text) => bpmnFlowElement(edge, from, to, text),
+});
+/** Every item of the BPMN toolbar that places elements, in the toolbar's order. */
+export const BPMN_TOOLBOX = {
+    framework: 'bpmn',
+    items: [
+        nodeItem('start-event', 'startEvent', 'bpmn.addStartEvent'),
+        nodeItem('end-event', 'endEvent', 'bpmn.addEndEvent'),
+        nodeItem('task', 'task', 'bpmn.addTask'),
+        nodeItem('exclusive-gateway', 'gatewayExclusive', 'bpmn.addExclusiveGateway'),
+        {
+            id: 'pool',
+            ...label('bpmn.addPool'),
+            texts: ['name', 'lanes'],
+            size: { w: POOL_REF_WIDTH, h: POOL_REF_HEIGHT },
+            build: (at, texts, local) => [bpmnPoolElement(at, texts, local)],
+        },
+        nodeItem('user-task', 'taskUser', 'bpmn.addUserTask'),
+        nodeItem('service-task', 'taskService', 'bpmn.addServiceTask'),
+        nodeItem('sub-process', 'subProcess', 'bpmn.addSubProcess'),
+        nodeItem('call-activity', 'callActivity', 'bpmn.addCallActivity'),
+        nodeItem('parallel-gateway', 'gatewayParallel', 'bpmn.addParallelGateway'),
+        nodeItem('message-start-event', 'startEventMessage', 'bpmn.addMessageStartEvent'),
+        nodeItem('timer-start-event', 'startEventTimer', 'bpmn.addTimerStartEvent'),
+        nodeItem('message-end-event', 'endEventMessage', 'bpmn.addMessageEndEvent'),
+        nodeItem('terminate-end-event', 'endEventTerminate', 'bpmn.addTerminateEndEvent'),
+        nodeItem('data-object', 'dataObject', 'bpmn.addDataObject'),
+        nodeItem('data-store', 'dataStore', 'bpmn.addDataStore'),
+        nodeItem('text-annotation', 'textAnnotation', 'bpmn.addTextAnnotation'),
+        nodeItem('group', 'group', 'bpmn.addGroup'),
+    ],
+    links: [
+        flowLink('sequence-flow', 'sequenceFlow', 'bpmn.sequenceFlowTool'),
+        flowLink('message-flow', 'messageFlow', 'bpmn.messageFlowTool'),
+        flowLink('association', 'association', 'bpmn.associationTool'),
+    ],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-bpmn",
   "description": "Labre bpmn framework for @formicoidea/labre-core.",
-  "version": "0.59.0",
+  "version": "0.60.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -35,7 +35,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.59.0",
+    "@formicoidea/labre-core": "0.60.0",
     "lit": "^3.2.0"
   }
 }