@formicoidea/labre-framework-wardley 0.41.0 → 0.42.0

package/dist/toolbar/config.js

@@ -1,10 +1,9 @@
-import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
+import { EdgelessCRUDIdentifier, legendToolbarAction, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
 import { WardleyBackgroundElementModel } from '@formicoidea/labre-core/model';
-import { BOARD_LEGEND_COMPONENTS, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BOARD_LEGEND_COMPONENTS, BOARD_RESIZE_TOGGLE, commandMoreAction, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
 import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
 import { html } from 'lit';
-import { createWardleyLegend } from '../legend.js';
-import { wardleyLegendIcon } from './icons.js';
+import { wardleyExportOwmIcon, wardleyLegendIcon } from './icons.js';
 /** The seven toolbar tooltips this file used to hard-code as English literals. */
 const EVOLUTION_AXIS_TOGGLE = [
     'com.labre.wardley.toolbar.evolution-axis',
@@ -219,29 +218,14 @@ export const wardleyToolbarConfig = {
                 booleanToggle('c.2-visibility-labels', VISIBILITY_LABELS_TOGGLE, VisibilityIcon, 'showVisibilityLabels'),
             ],
         },
-        // Generate the auto-legend from the components present inside this
-        // background's perimeter (+ a gradient-meaning block for gradient variants).
-        {
-            id: 'd.legend',
-            tooltipWording: BOARD_LEGEND_COMPONENTS,
-            icon: wardleyLegendIcon,
-            run(ctx) {
-                const models = ctx.getSurfaceModelsByType(WardleyBackgroundElementModel);
-                const bg = models[0];
-                if (!bg)
-                    return;
-                createWardleyLegend(ctx.std, bg);
-                ctx.std
-                    .getOptional(TelemetryProvider)
-                    ?.track('FrameworkLegendCreated', {
-                    framework: 'wardley',
-                    element: 'legend',
-                    page: 'whiteboard editor',
-                    segment: 'element toolbar',
-                    module: 'wardley toolbar',
-                });
-            },
-        },
+        // The OWM export, in the "⋮" — R5 of
+        // `docs/add-a-framework/02-framework-rules.md`, the position
+        // `bpmn.exportXml` and `c4.exportMermaid` already hold on their own boards.
+        // This module is registered ALWAYS-ON (`view.ts`) while the commands are
+        // flag-gated, and that needs no extra guard: the entry's `when` looks the
+        // command up in the registry and withdraws when the wardley flag left it
+        // unregistered.
+        commandMoreAction('z.export-owm', 'wardley.exportOwm', 'com.labre.commands.wardley.exportOwm', 'Export Wardley map (OWM)', wardleyExportOwmIcon),
     ],
     when: ctx => ctx.getSurfaceModelsByType(WardleyBackgroundElementModel).length > 0,
 };
@@ -249,3 +233,55 @@ export const wardleyToolbarExtension = ToolbarModuleExtension({
     id: BlockFlavourIdentifier('affine:surface:wardley'),
     config: wardleyToolbarConfig,
 });
+/**
+ * The map's flag-gated row, WHOLE: the Legend button and the Validation
+ * dropdown, in one module.
+ *
+ * ## Why they cannot be two modules
+ *
+ * `renderToolbar` merges exactly four slots per element — `<flavour>`,
+ * `custom:<flavour>` and the two `affine:surface:*` wildcards — and
+ * `ToolbarModuleExtension` binds by DI variant, so a second module claiming
+ * `custom:affine:surface:wardley` would throw
+ * `DuplicateServiceDefinitionError` before the editor finished setting up. Two
+ * slots, and Wardley has three things to put on a selected map: the axis and
+ * label toggles (always-on, `<flavour>`, above), the legend and the level of
+ * requirement. The precedent is C4's `c4BoardToolingToolbarConfig`.
+ *
+ * ## Why the legend moved OUT of the always-on half
+ *
+ * Because GENERATING one is tooling, and `docs/adr/0009` gates tooling: the
+ * flag off takes away the gesture that writes legend elements, exactly as it
+ * takes away the sub-menu that draws components. What the gesture already
+ * wrote is document CONTENT and keeps being painted — the box is plain shapes,
+ * text and `wardleyNode`s with no role, all drawn by the always-on renderers.
+ * The axis and label toggles stay always-on for the opposite reason: a stored
+ * map must keep its axes whatever the flag says.
+ *
+ * Sorting keeps the row readable across the merge — `a.` … `d.legend` from the
+ * two modules, then `z.validation` — whatever order they were registered in.
+ */
+export const wardleyBoardToolingToolbarConfig = {
+    actions: [
+        // `d.legend` and not the factory's default `b.legend`: the row is sorted
+        // lexicographically by id and the two axis groups already hold `b.` and
+        // `c.`, so the legend reads after the toggles it documents the map beside.
+        legendToolbarAction({
+            id: 'd.legend',
+            Model: WardleyBackgroundElementModel,
+            owner: 'wardley',
+            framework: 'wardley',
+            tooltipWording: BOARD_LEGEND_COMPONENTS,
+            icon: wardleyLegendIcon,
+        }),
+        // The generic dropdown, not a Wardley variant of it: the config names no
+        // framework — it reads the registered rules and profiles — so this is the
+        // very same object c4, bpmn and the context map register.
+        ...validationToolbarConfig.actions,
+    ],
+    when: wardleyToolbarConfig.when,
+};
+export const wardleyBoardToolingToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('custom:affine:surface:wardley'),
+    config: wardleyBoardToolingToolbarConfig,
+});

package/dist/toolbar/node-config.d.ts

@@ -1,4 +1,4 @@
-import type { NamedPalette } from '@formicoidea/labre-core/components/color-picker';
+import type { FrameworkPalette, NamedPalette } from '@formicoidea/labre-core/components/color-picker';
 import { type Color, type ShapeElementModel } from '@formicoidea/labre-core/model';
 import { type ChromeWording } from '@formicoidea/labre-core/shared/services';
 /**
@@ -42,4 +42,12 @@ export declare const WARDLEY_PALETTE_WORDINGS: readonly ChromeWording[];
  * colours are dropped in favour of the Wardley swatches above.
  */
 export declare const WARDLEY_PALETTE_LIST: NamedPalette[];
+/**
+ * Wardley's page of the colour pickers' carousel (`docs/adr/0027`) — the very
+ * list its own node picker is seeded with, offered on every other picker too:
+ * a connector between two components, a free-text label, a frame drawn over
+ * the map. Registered from the FLAG-GATED view extension, because offering
+ * hues is tooling (`docs/adr/0009`).
+ */
+export declare const WARDLEY_FRAMEWORK_PALETTE: FrameworkPalette;
 export declare const wardleyNodeToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/toolbar/node-config.js

@@ -150,6 +150,18 @@ export const WARDLEY_PALETTE_LIST = [
     ...WARDLEY_PALETTES,
     ...neutralPalettes(),
 ];
+/**
+ * Wardley's page of the colour pickers' carousel (`docs/adr/0027`) — the very
+ * list its own node picker is seeded with, offered on every other picker too:
+ * a connector between two components, a free-text label, a frame drawn over
+ * the map. Registered from the FLAG-GATED view extension, because offering
+ * hues is tooling (`docs/adr/0009`).
+ */
+export const WARDLEY_FRAMEWORK_PALETTE = {
+    framework: 'wardley',
+    labelWording: ['com.labre.framework.wardley', 'Wardley map'],
+    palettes: WARDLEY_PALETTE_LIST,
+};
 /**
  * Wardley nodes are {@link ShapeElementModel} subclasses, so the shape toolbar's
  * actions (which target `getSurfaceModelsByType(ShapeElementModel)`) operate on

package/dist/toolbar/wardley-senior-button.d.ts

@@ -12,6 +12,14 @@ export declare class EdgelessWardleySeniorButton extends EdgelessWardleySeniorBu
     enableActiveBackground: boolean;
     type: typeof EmptyTool;
     private _toggleMenu;
+    /**
+     * Lit while one of THIS framework's artefacts is armed under the cursor, as
+     * well as while its menu is open. The menu closes the moment the pointer goes
+     * to the board, so without this the ghost would be traceable to no button at
+     * all — and Shift+S, which walks that ghost along this framework's row, would
+     * read as a keystroke belonging to nothing.
+     */
+    private get _armed();
     render(): import("lit-html").TemplateResult<1>;
 }
 export {};

package/dist/toolbar/wardley-senior-button.js

@@ -1,7 +1,7 @@
 import { DefaultTool } from '@formicoidea/labre-core/blocks/surface';
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
 import { translateKey } from '@formicoidea/labre-core/shared/services';
-import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
+import { armedArtefact, EdgelessToolbarToolMixin, } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 import { SignalWatcher } from '@formicoidea/labre-core/global/lit';
 import { css, html, LitElement } from 'lit';
 import { wardleyToolbarIcon } from './icons.js';
@@ -80,6 +80,16 @@ export class EdgelessWardleySeniorButton extends EdgelessToolbarToolMixin(Signal
         const menu = this.createPopper('edgeless-wardley-menu', this);
         menu.element.edgeless = this.edgeless;
     }
+    /**
+     * Lit while one of THIS framework's artefacts is armed under the cursor, as
+     * well as while its menu is open. The menu closes the moment the pointer goes
+     * to the board, so without this the ghost would be traceable to no button at
+     * all — and Shift+S, which walks that ghost along this framework's row, would
+     * read as a keystroke belonging to nothing.
+     */
+    get _armed() {
+        return armedArtefact(this.gfx)?.owner === 'wardley';
+    }
     render() {
         return html `<edgeless-toolbar-button
       class="wardley-button"
@@ -87,7 +97,7 @@ export class EdgelessWardleySeniorButton extends EdgelessToolbarToolMixin(Signal
             ? ''
             : translateKey(this.edgeless.std, 'com.labre.framework.wardley', 'Wardley map')}
       .tooltipOffset=${4}
-      .active=${!!this.popper}
+      .active=${!!this.popper || this._armed}
       @click=${this._toggleMenu}
     >
       <div class="wardley-root">

package/dist/translations.js

@@ -14,7 +14,7 @@ import { WARDLEY_READING } from './reading.js';
 import { WARDLEY_ROLES } from './roles.js';
 import { WARDLEY_RULES } from './rules.js';
 import { KODAK_INERTIA_SEED, TEA_SHOP_SEED, WARDLEY_TEMPLATE_NAME_KODAK_INERTIA, WARDLEY_TEMPLATE_NAME_TEA_SHOP, } from './templates/maps.js';
-import { WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW, WARDLEY_TEMPLATE_NAME_LINK, } from './templates/index.js';
+import { WARDLEY_TEMPLATE_NAME_AREA_POLYGON, WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW, WARDLEY_TEMPLATE_NAME_LINK, } from './templates/index.js';
 import { WARDLEY_TOOLBAR_WORDINGS } from './toolbar/config.js';
 import { WARDLEY_PALETTE_WORDINGS } from './toolbar/node-config.js';
 /**
@@ -40,8 +40,8 @@ const exampleSeedEntries = () => [...Object.values(TEA_SHOP_SEED), ...Object.val
 /**
  * The auto-legend's own wordings — title, row captions, gradient blocks and
  * the Porter panel — derived from `legend.ts`'s own `WARDLEY_LEGEND_WORDINGS`,
- * the very table `createWardleyLegend` reads when it writes the group onto
- * the canvas.
+ * the very declarations the rows subscribe and the two extras write when the
+ * group lands on the canvas.
  */
 const legendSeedEntries = () => WARDLEY_LEGEND_WORDINGS.map(([key, fallback]) => ({
     key,
@@ -55,13 +55,14 @@ const toolbarChromeEntries = () => WARDLEY_TOOLBAR_WORDINGS.map(([key, fallback]
     source: 'chrome',
 }));
 /**
- * The four hand-composed cards' own tile names — chrome, not seeds: a
+ * The five hand-composed cards' own tile names — chrome, not seeds: a
  * `Template.nameKey`, re-resolved every time the panel opens, never written
  * into a document. See `templates/index.ts` and `templates/maps.ts`.
  */
 const templateNameEntries = () => [
     WARDLEY_TEMPLATE_NAME_LINK,
     WARDLEY_TEMPLATE_NAME_EVOLUTION_ARROW,
+    WARDLEY_TEMPLATE_NAME_AREA_POLYGON,
     WARDLEY_TEMPLATE_NAME_TEA_SHOP,
     WARDLEY_TEMPLATE_NAME_KODAK_INERTIA,
 ].map(([key, fallback]) => ({ key, fallback, source: 'chrome' }));

package/dist/view.js

@@ -1,5 +1,6 @@
-import { InterchangeExtension, morphToolbarConfig, ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { InterchangeExtension, morphToolbarConfig, ReadingProfileExtension, tagsToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { AuditCriterionExtension, ToolbarModuleExtension, toolbarModuleKey, UniverseTagDefsExtension, } from '@formicoidea/labre-core/shared/services';
+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 { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
@@ -21,8 +22,8 @@ import { WardleyInteraction, WardleyView } from './element-view.js';
 import { WardleyNodeRendererExtension } from './node/node-renderer.js';
 import { WardleyNodeView } from './node/node-view.js';
 import { WardleyPorterWatcher } from './node/porter-watcher.js';
-import { wardleyNodeToolbarExtension } from './toolbar/node-config.js';
-import { wardleyToolbarExtension } from './toolbar/config.js';
+import { WARDLEY_FRAMEWORK_PALETTE, wardleyNodeToolbarExtension, } from './toolbar/node-config.js';
+import { wardleyBoardToolingToolbarExtension, wardleyToolbarExtension, } from './toolbar/config.js';
 import { wardleySeniorTool } from './toolbar/senior-tool.js';
 /**
  * Wardley rendering — ALWAYS registered, independent of any flag. Disabling
@@ -106,18 +107,15 @@ export class WardleyViewExtension extends ViewExtensionProvider {
             // off contributes none and `map.audit` finds nothing to ask about — while
             // `ai-audit` independently decides whether the command exists at all.
             context.register(AuditCriterionExtension(WARDLEY_AUDIT_CRITERIA));
-            // The Validation dropdown on a selected map's contextual toolbar. A
-            // SECOND module on the same element, through the `custom:` flavour slot
-            // (the pattern `gfx/mindmap` uses on `custom:affine:surface:shape`):
-            // `wardleyToolbarExtension` is registered always-on because a stored map
-            // must keep its axes and labels, while choosing how hard to check it is
-            // tooling and belongs here. The config itself names no framework — it
-            // reads roles and profiles — so a second framework registers the very
-            // same object on its own flavour.
-            context.register(ToolbarModuleExtension({
-                id: BlockFlavourIdentifier('custom:affine:surface:wardley'),
-                config: validationToolbarConfig,
-            }));
+            // The Legend button and the Validation dropdown on a selected map's
+            // contextual toolbar — ONE module, through the `custom:` flavour slot
+            // (the pattern `gfx/mindmap` uses on `custom:affine:surface:shape`), for
+            // the reason `wardleyBoardToolingToolbarConfig` states: a flavour carries
+            // exactly one, and a second would throw at set-up. Here and not in the
+            // always-on half because both are TOOLING — generating a legend and
+            // choosing how hard to check the map — while `wardleyToolbarExtension`
+            // stays always-on so a stored map keeps its axes and labels.
+            context.register(wardleyBoardToolingToolbarExtension);
             // The four natures — Wardley's type-3 qualification (MF3, ADR 0007).
             // Seeded on the SAME mechanism a host uses for its own taxonomy: the
             // library ships one real pack, and a client's private extension is a
@@ -179,6 +177,12 @@ export class WardleyViewExtension extends ViewExtensionProvider {
             // the flag without either side naming the other.
             context.register(ReadingProfileExtension(WARDLEY_READING));
             context.register(wardleySeniorTool);
+            // Wardley's page of the colour pickers' carousel (`docs/adr/0027`).
+            // Here, beside the senior tool, because offering hues is TOOLING: a map
+            // drawn while the flag was on keeps every colour it was painted with
+            // when the flag goes off — the shelf that offers more of them is what
+            // goes away (`docs/adr/0009`).
+            context.register(FrameworkPaletteExtension(WARDLEY_FRAMEWORK_PALETTE));
             // The Templates-panel category — tooling, so it goes with the flag (#244).
             context.register(TemplateCategoryExtension(wardleyTemplateCategory));
             // The Wardley commands — thirteen artefacts plus the two directions of

package/package.json

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