@formicoidea/labre-framework-bpmn 0.42.0 → 0.45.0

package/dist/toolbar/node-config.js

@@ -0,0 +1,88 @@
+import { paletteColorAction, shapeToolbarConfig, } from '@formicoidea/labre-core/gfx/shape';
+import { BpmnNodeElementModel } from '@formicoidea/labre-core/model';
+import { ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
+import { bpmnLabelMode } from '../consts.js';
+import { BPMN_PALETTE_LIST } from './palette.js';
+/**
+ * The shape toolbar's actions a BPMN node keeps.
+ *
+ * A BPMN node IS a `ShapeElementModel`, so the shape actions (which target
+ * `getSurfaceModelsByType(ShapeElementModel)`) operate on it directly — but
+ * `renderToolbar` merges by flavour KEY, so none of them reach a node until a
+ * module is registered on `affine:surface:bpmnNode`. This is that module, and
+ * it keeps what Edgy keeps (the reference the PO cited):
+ *
+ * - `d.style` — the scribbled / general line style;
+ * - `f.text` — "Add text", narrowed below to inscribed kinds;
+ * - `f2.text-fit` and every `g.text-*` — they already hide themselves on a
+ *   node with no inner text, which is every external kind drawn since R38.
+ *
+ * Dropped: `c.switch-type` (the KIND decides the native shape — a diamond is a
+ * gateway because it is a gateway; turning it into an ellipse would paint a
+ * start event's outline with a gateway's marker; "Change type" is the morph
+ * module's job) and `f1.edit-vertices` (no BPMN symbol is a free polygon).
+ */
+const KEEP_FROM_SHAPE = (id) => id === 'd.style' ||
+    id === 'f.text' ||
+    id === 'f2.text-fit' ||
+    id.startsWith('g.text-');
+/**
+ * Every selected BPMN node wears its name INSIDE the shape.
+ *
+ * An event, a gateway or a data shape names itself with a grouped `bpmn:label`
+ * text under the symbol (R38), so "Add text" on one would write a second,
+ * inner name the notation never draws there. The gesture exists for the
+ * inscribed kinds only — the same gate `bpmnNodeEditsInnerText` puts on the
+ * double-click, minus the legacy exception: a legacy event's inner text is
+ * already there, and "Add text" only ever shows on a node with none.
+ */
+export function bpmnSelectionIsInscribed(ctx) {
+    const models = ctx.getSurfaceModelsByType(BpmnNodeElementModel);
+    return (models.length > 0 &&
+        models.every(model => bpmnLabelMode(model.kind) === 'inscribed'));
+}
+/** Narrow a shape action's own `when` with {@link bpmnSelectionIsInscribed}. */
+function inscribedOnly(action) {
+    const when = action.when;
+    return {
+        ...action,
+        when: (ctx) => bpmnSelectionIsInscribed(ctx) &&
+            (typeof when === 'function' ? when(ctx) : when !== false),
+    };
+}
+/**
+ * Fill, stroke colour, stroke width and stroke style — the picker Edgy and
+ * Wardley use, seeded with BPMN's two notation hues and the neutrals.
+ * `paletteColorAction` and the shape's own `e.color` expose the same four
+ * controls (both render `edgeless-shape-color-picker`, which carries the
+ * width / style panel); the palette one is taken because it is Edgy's.
+ *
+ * On the glyph-bodied kinds (`dataObject`, `dataStore`, `textAnnotation`) the
+ * native shape is born with `strokeStyle: None` and the renderer's glyph draws
+ * the silhouette from `strokeColor` / `fillColor`. Picking a visible stroke
+ * style there makes the native rectangle paint its outline around the glyph —
+ * an honest result of the author's pick, so it is left to the author rather
+ * than filtered out here.
+ */
+const bpmnColorAction = paletteColorAction('e.color', BPMN_PALETTE_LIST);
+export const bpmnNodeToolbarConfig = {
+    actions: [
+        ...shapeToolbarConfig.actions
+            .filter(action => KEEP_FROM_SHAPE(action.id))
+            .map(action => (action.id === 'f.text' ? inscribedOnly(action) : action)),
+        bpmnColorAction,
+    ],
+    when: shapeToolbarConfig.when,
+};
+/**
+ * The base shape features on a selected BPMN node, on the BARE flavour key.
+ * Registered from the ALWAYS-ON view extension: recolouring or re-typesetting
+ * a stored element is editing content, not tooling (`docs/adr/0009`). The
+ * "Change type" morph, which IS tooling, takes an owner-suffixed key beside
+ * it (`view.ts`).
+ */
+export const bpmnNodeToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('affine:surface:bpmnNode'),
+    config: bpmnNodeToolbarConfig,
+});

package/dist/toolbar/senior-tool.d.ts

@@ -1 +1 @@
-export declare const bpmnSeniorTool: import("@formicoidea/labre-core/store").ExtensionType;
+export declare const bpmnSeniorTool: import("@formicoidea/labre-core/_pkgs/store").ExtensionType;

package/dist/view.js

@@ -2,14 +2,14 @@ import { FrameworkBackgroundInteractionExtension, InterchangeExtension, morphToo
 import { FrameworkPaletteExtension } from '@formicoidea/labre-core/components/color-picker';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { TemplateCategoryExtension } from '@formicoidea/labre-core/gfx/template';
-import { ToolbarModuleExtension } from '@formicoidea/labre-core/shared/services';
+import { ToolbarModuleExtension, toolbarModuleKey, } from '@formicoidea/labre-core/shared/services';
 import { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
 import { RoleVocabularyExtension } from '@formicoidea/labre-core/std/gfx';
 import { BPMN_POOL_BACKGROUND } from './background.js';
 import { bpmnCommandIcons, bpmnCommands } from './commands.js';
 import { effects } from './effects.js';
 import { BPMN_INTERCHANGE } from './interchange.js';
-import { BPMN_MORPH_SPEC } from './morph.js';
+import { BPMN_GROUP_MORPH_SPEC, BPMN_MORPH_SPEC } from './morph.js';
 import { BPMN_PROFILES } from './profiles.js';
 import { BPMN_READINGS } from './reading.js';
 import { BPMN_ROLES } from './roles.js';
@@ -20,6 +20,7 @@ import { BpmnPoolView } from './element-view.js';
 import { BpmnNodeRendererExtension } from './node/node-renderer.js';
 import { BpmnNodeView } from './node/node-view.js';
 import { bpmnPoolToolbarExtension, bpmnPoolToolingToolbarExtension, } from './toolbar/config.js';
+import { bpmnNodeToolbarExtension } from './toolbar/node-config.js';
 import { BPMN_FRAMEWORK_PALETTE } from './toolbar/palette.js';
 import { bpmnSeniorTool } from './toolbar/senior-tool.js';
 /**
@@ -51,6 +52,11 @@ export class BpmnRenderViewExtension extends ViewExtensionProvider {
             // otherwise, and the toolbar toggle is what writes it.
             context.register(FrameworkBackgroundInteractionExtension(BPMN_POOL_BACKGROUND));
             context.register(bpmnPoolToolbarExtension);
+            // The base shape features on a selected NODE — colours, stroke, text
+            // style — on the BARE `affine:surface:bpmnNode` key, like Wardley's and
+            // EDGY's node modules. Always on: recolouring a stored element is editing
+            // content, not tooling (`docs/adr/0009`).
+            context.register(bpmnNodeToolbarExtension);
         }
     }
 }
@@ -94,25 +100,41 @@ export class BpmnViewExtension extends ViewExtensionProvider {
             // The "Change type" dropdown on a selected NODE's contextual toolbar —
             // the generic module, parameterized by BPMN's own families table.
             //
-            // `affine:surface:bpmnNode` is a FREE slot, and class inheritance has
-            // nothing to do with it: `renderToolbar` merges by flavour KEY — the
-            // element's own, its `custom:` twin and the `affine:surface:*` wildcards
-            // — so `shapeToolbarExtension`, which binds `affine:surface:shape`, never
+            // ## Why the key carries an owner
+            //
+            // `renderToolbar` merges by flavour KEY — the element's own, its
+            // `custom:` twin and the `affine:surface:*` wildcards — so
+            // `shapeToolbarExtension`, which binds `affine:surface:shape`, never
             // reaches a bpmn node however much of `ShapeElementModel` the class
-            // inherits. Nothing claimed this key before, so the registration is purely
-            // additive: it joins the wildcard entries (tags, validation) that a node
-            // already gets, and a second module claiming the same key would throw
-            // `DuplicateServiceDefinitionError` before the editor finished setting up.
+            // inherits. The bare `affine:surface:bpmnNode` key is now taken by the
+            // always-on `bpmnNodeToolbarExtension` (the shape's base features), and
+            // a second module on it would throw `DuplicateServiceDefinitionError`
+            // at setup. `toolbarModuleKey` lifts that ceiling: the morph is the
+            // DISTINCT variant `affine:surface:bpmnNode#bpmn-morph`, and the
+            // registry hands it to the same row.
             //
-            // Registered HERE, in the flag-gated half, because a morph is TOOLING: a
-            // node drawn while the flag was on keeps its kind, its role, its glyph
-            // and its place in every rule when the flag goes off — it just stops
-            // being something the toolbar offers to say more precisely
-            // (`docs/adr/0009`).
+            // ## Why here
+            //
+            // In the flag-gated half, because a morph is TOOLING: a node drawn while
+            // the flag was on keeps its kind, its role, its glyph and its place in
+            // every rule when the flag goes off — it just stops being something the
+            // toolbar offers to say more precisely (`docs/adr/0009`).
             context.register(ToolbarModuleExtension({
-                id: BlockFlavourIdentifier('affine:surface:bpmnNode'),
+                id: BlockFlavourIdentifier(toolbarModuleKey('affine:surface:bpmnNode', 'bpmn-morph')),
                 config: morphToolbarConfig(BPMN_MORPH_SPEC),
             }));
+            // The same dropdown on the GROUP row. An event, a gateway or a data
+            // shape is born as a native group of the symbol and its gravitating
+            // label (R38), and a click selects the group — so, exactly as Wardley,
+            // C4 and UML do for their composites, the morph is also registered on
+            // `custom:affine:surface:group` under an owner, and
+            // `BPMN_GROUP_MORPH_SPEC` resolves the node inside (refusing any group
+            // that is not one BPMN external-label artefact). Flag-gated for the
+            // same reason as the node row.
+            context.register(ToolbarModuleExtension({
+                id: BlockFlavourIdentifier(toolbarModuleKey('custom:affine:surface:group', 'bpmn-morph')),
+                config: morphToolbarConfig(BPMN_GROUP_MORPH_SPEC),
+            }));
             // The reversed reading (MF3): what the process says about an artefact, on
             // demand. Four profiles because BPMN has four parent-less node families
             // (`reading.ts` says why the notation refuses a common root). The CLICK

package/package.json

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