@formicoidea/labre-framework-wardley 0.35.0 → 0.37.0

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

@@ -1 +1,21 @@
+import { type Color, type Palette, type ShapeElementModel } from '@formicoidea/labre-core/model';
+/**
+ * What a picked swatch WRITES on a Wardley node.
+ *
+ * The identity on every artefact but one. A zone is drawn over the components
+ * it groups, so its fill is a WASH — `#c6dbfc40`, the alpha being the whole of
+ * what keeps the map readable underneath — and a picker that wrote the swatch
+ * as-is would replace it with an opaque hue and hide the map the zone annotates
+ * (recette of #213). So a swatch picked for an area keeps the zone's alpha.
+ *
+ * Only a bare 6-digit hex is touched: a value that already carries alpha is
+ * somebody's deliberate choice from the custom picker, and a theme token
+ * (`--affine-…`) is not a hex at all and must reach the document intact.
+ */
+export declare function wardleyFillColor(model: ShapeElementModel, value: Color): Color;
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours are dropped in favour of the Wardley swatches above.
+ */
+export declare const WARDLEY_PALETTE_LIST: Palette[];
 export declare const wardleyNodeToolbarExtension: import("@formicoidea/labre-core/store").ExtensionType;

package/dist/toolbar/node-config.js

@@ -1,17 +1,110 @@
-import { shapeToolbarConfig } from '@formicoidea/labre-core/gfx/shape';
+import { neutralPalettes, paletteColorAction, shapeToolbarConfig, } from '@formicoidea/labre-core/gfx/shape';
+import { WardleyNodeElementModel, } from '@formicoidea/labre-core/model';
 import { ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
 import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
+import { AREA_FILL, INERTIA_COLOR, METHOD_FILL, WARDLEY_RED, } from '../node/consts.js';
+/** The two hex digits `AREA_FILL` carries — the zone's ~25 % opacity. */
+const AREA_ALPHA = AREA_FILL.slice(-2);
+/** A plain 6-digit hex, the only shape a swatch value takes. */
+const SIX_DIGIT_HEX = /^#[0-9a-f]{6}$/i;
+/**
+ * What a picked swatch WRITES on a Wardley node.
+ *
+ * The identity on every artefact but one. A zone is drawn over the components
+ * it groups, so its fill is a WASH — `#c6dbfc40`, the alpha being the whole of
+ * what keeps the map readable underneath — and a picker that wrote the swatch
+ * as-is would replace it with an opaque hue and hide the map the zone annotates
+ * (recette of #213). So a swatch picked for an area keeps the zone's alpha.
+ *
+ * Only a bare 6-digit hex is touched: a value that already carries alpha is
+ * somebody's deliberate choice from the custom picker, and a theme token
+ * (`--affine-…`) is not a hex at all and must reach the document intact.
+ */
+export function wardleyFillColor(model, value) {
+    if (!(model instanceof WardleyNodeElementModel))
+        return value;
+    if (model.kind !== 'area')
+        return value;
+    if (typeof value !== 'string' || !SIX_DIGIT_HEX.test(value))
+        return value;
+    return `${value}${AREA_ALPHA}`;
+}
+/**
+ * The Wardley **evolution cycle**, surfaced as ready-made swatches in the node
+ * colour picker: Wonder / Peace / War, the three climatic phases a component
+ * travels through in Simon Wardley's pattern — saturated first, then the light
+ * shades for a fill under a label — followed by the three colours the notation
+ * itself already uses (the evolution arrow's red, the inertia bar, a method's
+ * neutral fill).
+ *
+ * They are SHORTCUTS, never constraints: nothing in the map reads a colour, so
+ * an author is free to ignore them, and the custom picker stays one click away.
+ */
+const WARDLEY_PALETTES = [
+    { key: 'Wonder', value: '#3ec9f2' },
+    { key: 'Peace', value: '#5b9cf6' },
+    { key: 'War', value: '#9d6df0' },
+    { key: 'Wonder light', value: '#b9e9fa' },
+    { key: 'Peace light', value: '#c6dbfc' },
+    { key: 'War light', value: '#d9c9fa' },
+    { key: 'Wardley red', value: WARDLEY_RED },
+    { key: 'Inertia', value: INERTIA_COLOR },
+    { key: 'Method grey', value: METHOD_FILL },
+];
+/**
+ * From the default editor palette we keep ONLY the neutrals — the historical
+ * colours are dropped in favour of the Wardley swatches above.
+ */
+export const WARDLEY_PALETTE_LIST = [
+    ...WARDLEY_PALETTES,
+    ...neutralPalettes(),
+];
 /**
  * Wardley nodes are {@link ShapeElementModel} subclasses, so the shape toolbar's
  * actions (which target `getSurfaceModelsByType(ShapeElementModel)`) operate on
- * them directly. We re-register only the color / line-style actions under the
- * `wardleyNode` flavour so the circle's fill / stroke color / stroke width are
- * editable — while excluding the shape-only actions (switch type, add inner
- * text, edit vertices) that don't make sense for a Wardley node.
+ * them directly. We re-register only the line-style action plus a colour picker
+ * seeded with the Wardley swatches, so the circle's fill / stroke color / stroke
+ * width stay editable — while excluding the shape-only actions (switch type, add
+ * inner text) that don't make sense for a Wardley node.
+ */
+const KEEP_ACTION_IDS = new Set(['d.style']);
+/**
+ * The shape toolbar's vertex editor, kept for ONE artefact: an area drawn as a
+ * polygon.
+ *
+ * Every other polygon on a Wardley map has an outline that IS the notation — an
+ * accelerator points right and a decelerator points left, and dragging a barb
+ * would turn a statement about the climate into a grey blob. A zone is the
+ * opposite: its whole job is to follow the components it groups, so moving its
+ * corners is the point of choosing the polygon over the rectangle.
+ *
+ * The shape action's own `when` already asks for a single ungrouped polygon —
+ * which excludes the two climate arrows, since both are grouped with their name
+ * — but it is narrowed HERE to `kind === 'area'` rather than left to rely on
+ * that: an arrow selected from inside its group, or one an author ungrouped,
+ * would otherwise offer a gesture that can only damage it.
  */
-const KEEP_ACTION_IDS = new Set(['e.color', 'd.style']);
+const VERTEX_ACTION_ID = 'f1.edit-vertices';
+function isAreaSelection(ctx) {
+    const models = ctx.getSurfaceModelsByType(WardleyNodeElementModel);
+    return models.length > 0 && models.every(model => model.kind === 'area');
+}
+const areaVertexActions = shapeToolbarConfig.actions
+    .filter(action => action.id === VERTEX_ACTION_ID)
+    .map(action => {
+    const when = action.when;
+    return {
+        ...action,
+        when: (ctx) => isAreaSelection(ctx) &&
+            (typeof when === 'function' ? when(ctx) : when !== false),
+    };
+});
 const wardleyNodeToolbarConfig = {
-    actions: shapeToolbarConfig.actions.filter(action => KEEP_ACTION_IDS.has(action.id)),
+    actions: [
+        ...shapeToolbarConfig.actions.filter(action => KEEP_ACTION_IDS.has(action.id)),
+        ...areaVertexActions,
+        paletteColorAction('e.color', WARDLEY_PALETTE_LIST, wardleyFillColor),
+    ],
     when: shapeToolbarConfig.when,
 };
 export const wardleyNodeToolbarExtension = ToolbarModuleExtension({

package/dist/view.js

@@ -20,6 +20,7 @@ import { WardleyElementRendererExtension } from './element-renderer.js';
 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 { wardleySeniorTool } from './toolbar/senior-tool.js';
@@ -51,6 +52,15 @@ export class WardleyRenderViewExtension extends ViewExtensionProvider {
             context.register(WardleyInteraction);
             context.register(wardleyToolbarExtension);
             context.register(wardleyNodeToolbarExtension);
+            // A Porter's-forces glyph says the same thing twice — the letter in the
+            // circle and the `wardley:competition` tag on it — and this keeps the two
+            // spellings equal in both directions. HERE, in the always-on half, for
+            // `docs/adr/0009`'s reason: it authors nothing. It creates no element,
+            // offers no button, adds no artefact; it keeps an element ALREADY in the
+            // document coherent with itself, which a force drawn while the Wardley
+            // button was on must stay when the button goes off. Edgeless-only because
+            // a selection, a canvas text editor and a surface are all edgeless.
+            context.register(WardleyPorterWatcher);
         }
     }
 }

package/package.json

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