@formicoidea/labre-framework-ddd-context-map 0.32.0 → 0.34.1

package/dist/toolbar/board-config.js

@@ -0,0 +1,87 @@
+import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
+import { createAutoLegend, dddLegendIcon } from '@formicoidea/labre-ddd-shared';
+import { ContextMapBoardElementModel } from '@formicoidea/labre-core/model';
+import { BOARD_LEGEND_NOTATION, BOARD_RESIZE_TOGGLE, TelemetryProvider, ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
+import { html } from 'lit';
+import { CONTEXT_MAP_AUTO_LEGEND } from '../legend.js';
+const ResizeIcon = html `<svg
+  width="24"
+  height="24"
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="1.6"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+>
+  <path d="M9 5H5v4M15 19h4v-4" />
+  <path d="M5 5l6 6M19 19l-6-6" />
+</svg>`;
+/**
+ * The selected board's contextual toolbar: the resize toggle, and the automatic
+ * legend of what is actually drawn on the board. Registered ALWAYS-ON
+ * (`DddContextMapRenderViewExtension`) — a stored board must stay usable with
+ * the Context Map button switched off (`docs/adr/0009`), legend included: a
+ * legend is real editable elements, so generating one is authoring a document,
+ * not tooling that a flag may take away.
+ *
+ * This is THE legend of the module. The palette used to also offer a static,
+ * full-notation one; the PO's recette (27/08/2026) removed it — two legends were
+ * two answers to one question, and the honest answer is what is actually drawn.
+ * Same single-gesture shape as Core Domain Chart.
+ */
+export const contextMapBoardToolbarConfig = {
+    actions: [
+        {
+            id: 'a.toggle-resize',
+            tooltipWording: BOARD_RESIZE_TOGGLE,
+            icon: ResizeIcon,
+            active(ctx) {
+                const models = ctx.getSurfaceModelsByType(ContextMapBoardElementModel);
+                return models.length > 0 && models.every(model => model.resizeEnabled);
+            },
+            run(ctx) {
+                const models = ctx.getSurfaceModelsByType(ContextMapBoardElementModel);
+                if (!models.length)
+                    return;
+                const enable = !models.every(model => model.resizeEnabled);
+                ctx.std.store.captureSync();
+                const crud = ctx.std.get(EdgelessCRUDIdentifier);
+                for (const model of models) {
+                    crud.updateElement(model.id, { resizeEnabled: enable });
+                }
+            },
+        },
+        {
+            id: 'b.legend',
+            tooltipWording: BOARD_LEGEND_NOTATION,
+            icon: dddLegendIcon,
+            run(ctx) {
+                const board = ctx.getSurfaceModelsByType(ContextMapBoardElementModel)[0];
+                if (!board)
+                    return;
+                createAutoLegend(ctx.std, board, CONTEXT_MAP_AUTO_LEGEND);
+                ctx.std
+                    .getOptional(TelemetryProvider)
+                    ?.track('FrameworkLegendCreated', {
+                    // The WIRE value, which is not the module id: the framework is
+                    // `ddd-context-map` in code and `context-map` in PostHog
+                    // (`frameworks.ts` `telemetryKey`, and the only value
+                    // `FrameworkElementEvent` accepts). Same convention as Wardley's own
+                    // legend button, so the two are comparable.
+                    framework: 'context-map',
+                    element: 'legend',
+                    page: 'whiteboard editor',
+                    segment: 'element toolbar',
+                    module: 'context-map toolbar',
+                });
+            },
+        },
+    ],
+    when: (ctx) => ctx.getSurfaceModelsByType(ContextMapBoardElementModel).length > 0,
+};
+export const contextMapBoardToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('affine:surface:contextMap'),
+    config: contextMapBoardToolbarConfig,
+});

package/dist/toolbar/context-map-menu.d.ts

@@ -3,7 +3,7 @@ import { EdgelessCommandMenu } from '@formicoidea/labre-core/widgets/edgeless-to
 /**
  * Context Map palette, rendered from `contextMapCommands` for the
  * `senior-menu` surface (`docs/adr/0008`). Keeps the DDD palettes' tighter gap
- * — it is the widest one, at 12 buttons.
+ * — it is the widest one, at 13 buttons.
  */
 export declare class EdgelessDddContextMapMenu extends EdgelessCommandMenu {
     static styles: import("lit").CSSResultGroup[];

package/dist/toolbar/context-map-menu.js

@@ -4,7 +4,7 @@ import { css } from 'lit';
 /**
  * Context Map palette, rendered from `contextMapCommands` for the
  * `senior-menu` surface (`docs/adr/0008`). Keeps the DDD palettes' tighter gap
- * — it is the widest one, at 12 buttons.
+ * — it is the widest one, at 13 buttons.
  */
 export class EdgelessDddContextMapMenu extends EdgelessCommandMenu {
     constructor() {

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

@@ -2,5 +2,6 @@ import { DddSeniorButtonBase } from '@formicoidea/labre-ddd-shared';
 export declare class EdgelessDddContextMapSeniorButton extends DddSeniorButtonBase {
     protected menuTag: "edgeless-ddd-context-map-menu";
     protected label: string;
+    protected labelKey: string;
     protected icon: import("lit-html").TemplateResult<2>;
 }

package/dist/toolbar/senior-button.js

@@ -4,6 +4,7 @@ export class EdgelessDddContextMapSeniorButton extends DddSeniorButtonBase {
         super(...arguments);
         this.menuTag = 'edgeless-ddd-context-map-menu';
         this.label = 'Context Map';
+        this.labelKey = 'com.labre.framework.ddd-context-map';
         this.icon = contextMapToolbarIcon;
     }
 }

package/dist/toolbar/senior-tool.js

@@ -3,6 +3,7 @@ import { html } from 'lit';
 /** Independent senior tool — Context Map. */
 export const contextMapSeniorTool = SeniorToolExtension('ddd-context-map', ({ block }) => ({
     name: 'Context Map',
+    labelKey: 'com.labre.framework.ddd-context-map',
     content: html `<edgeless-ddd-context-map-senior-button
       .edgeless=${block}
     ></edgeless-ddd-context-map-senior-button>`,

package/dist/translations.d.ts

@@ -1,14 +1,14 @@
 import { type TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
 /**
- * THIS framework's contribution to the translation-key manifest.
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key Context Mapping can hand to `TranslationProvider.t`,
+ * derived from the very declarations the editor registers (never restated).
  *
- * Its command labels and descriptions are built from a TEMPLATE, so the
- * concrete keys exist nowhere but in the declarations themselves and the
- * core manifest could not restate them even if it wanted to. The
- * contribution therefore ships WITH the framework: in the bundled
- * distribution `@formicoidea/labre-framework-ddd-context-map` carries it, and a host
- * composes it into its catalogue exactly as it already composes
- * `contextMapCommands` into the command registry. See
- * `packages/affine/all/src/translations.ts`.
+ * It lives HERE, not in `@labre/affine/translations`, because the bundled
+ * distribution splits the library along exactly this line:
+ * `@formicoidea/labre-core` is the editor MINUS the frameworks, and a host that
+ * installs `@formicoidea/labre-framework-ddd-context-map` composes this export
+ * into the catalogue it builds — the same sentence that already holds for
+ * `contextMapCommands`. See `packages/affine/all/src/translations.ts`.
  */
 export declare const contextMapTranslationEntries: TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -1,15 +1,26 @@
-import { commandTranslationEntries, } from '@formicoidea/labre-core/std';
+import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
+import { CONTEXT_MAP_BACKGROUND } from './background.js';
 import { contextMapCommands } from './commands.js';
+import { CONTEXT_MAP_NUDGES } from './nudges.js';
+import { CONTEXT_MAP_PROFILES } from './profiles.js';
+import { CONTEXT_MAP_ROLES } from './roles.js';
+import { CONTEXT_MAP_RULES } from './rules.js';
 /**
- * THIS framework's contribution to the translation-key manifest.
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key Context Mapping can hand to `TranslationProvider.t`,
+ * derived from the very declarations the editor registers (never restated).
  *
- * Its command labels and descriptions are built from a TEMPLATE, so the
- * concrete keys exist nowhere but in the declarations themselves and the
- * core manifest could not restate them even if it wanted to. The
- * contribution therefore ships WITH the framework: in the bundled
- * distribution `@formicoidea/labre-framework-ddd-context-map` carries it, and a host
- * composes it into its catalogue exactly as it already composes
- * `contextMapCommands` into the command registry. See
- * `packages/affine/all/src/translations.ts`.
+ * It lives HERE, not in `@labre/affine/translations`, because the bundled
+ * distribution splits the library along exactly this line:
+ * `@formicoidea/labre-core` is the editor MINUS the frameworks, and a host that
+ * installs `@formicoidea/labre-framework-ddd-context-map` composes this export
+ * into the catalogue it builds — the same sentence that already holds for
+ * `contextMapCommands`. See `packages/affine/all/src/translations.ts`.
  */
-export const contextMapTranslationEntries = commandTranslationEntries(contextMapCommands);
+export const contextMapTranslationEntries = mergeTranslationEntries(commandTranslationEntries(contextMapCommands), 
+// The catalogue's own group headers, derived from the very categories
+// these commands declare. They ship WITH the framework because core's
+// registry names no framework category in the bundled distribution, so a
+// host that composed core's manifest alone drew translated entries under
+// English headers (#183).
+commandCategoryTranslationEntries(contextMapCommands), collectTranslationKeys('role', CONTEXT_MAP_ROLES), collectTranslationKeys('background', CONTEXT_MAP_BACKGROUND), collectTranslationKeys('rule', CONTEXT_MAP_RULES), collectTranslationKeys('nudge', CONTEXT_MAP_NUDGES), collectTranslationKeys('profile', CONTEXT_MAP_PROFILES));

package/dist/view.d.ts

@@ -1,6 +1,22 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '@formicoidea/labre-core/ext-loader';
 /**
- * Context Map — independently flag-gated (`ddd-context-map`).
+ * Context Map rendering — ALWAYS registered, independent of any flag.
+ * Disabling `ddd-context-map` hides only the creation tooling (see
+ * {@link DddContextMapViewExtension}); boards already drawn must still paint,
+ * stay selectable, stay movable and keep their contextual toolbar. See
+ * `docs/adr/0009`.
+ */
+export declare class DddContextMapRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * Context Map creation tooling — independently flag-gated
+ * (`ddd-context-map`): the senior toolbar button, its palette and the
+ * validation rules, profiles and quality nudges. Both halves are tooling: a map
+ * drawn while the flag was on keeps rendering when it goes off, it just stops
+ * being checked — and the profile it was put on stays written, unread, until the
+ * flag comes back.
  *
  * Note: its Templates-panel category is registered by the aggregate package's
  * {@link DddTemplatesViewExtension} (gated by `ddd-templates`), so templates

package/dist/view.js

@@ -1,10 +1,54 @@
+import { QualityNudgeExtension, validationToolbarConfig, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
-import { CommandExtension } from '@formicoidea/labre-core/std';
+import { ToolbarModuleExtension } from '@formicoidea/labre-core/shared/services';
+import { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
+import { RoleVocabularyExtension } from '@formicoidea/labre-core/std/gfx';
 import { contextMapCommandIcons, contextMapCommands } from './commands.js';
 import { contextMapEffects } from './effects.js';
+import { ContextMapRendererExtension } from './element-renderer.js';
+import { ContextMapInteraction, ContextMapView } from './element-view.js';
+import { CONTEXT_MAP_NUDGES } from './nudges.js';
+import { CONTEXT_MAP_PROFILES } from './profiles.js';
+import { CONTEXT_MAP_ROLES } from './roles.js';
+import { CONTEXT_MAP_RULES } from './rules.js';
+import { contextMapBoardToolbarExtension } from './toolbar/board-config.js';
 import { contextMapSeniorTool } from './toolbar/senior-tool.js';
 /**
- * Context Map — independently flag-gated (`ddd-context-map`).
+ * Context Map rendering — ALWAYS registered, independent of any flag.
+ * Disabling `ddd-context-map` hides only the creation tooling (see
+ * {@link DddContextMapViewExtension}); boards already drawn must still paint,
+ * stay selectable, stay movable and keep their contextual toolbar. See
+ * `docs/adr/0009`.
+ */
+export class DddContextMapRenderViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-ddd-context-map-render-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(ContextMapView);
+        context.register(ContextMapRendererExtension);
+        // The role VOCABULARY, always on. A role is written in the DOCUMENT, not in
+        // the tooling: the direction reveal of a typed relationship, the inversion
+        // command and the toolbar entry that must not lie about one all read this,
+        // and they have to keep working on a map drawn while the flag was on and
+        // opened while it is off (`docs/adr/0009`, `docs/adr/0010`). The rules that
+        // JUDGE those roles stay in the flag-gated extension below.
+        context.register(RoleVocabularyExtension(CONTEXT_MAP_ROLES));
+        if (this.isEdgeless(context.scope)) {
+            context.register(ContextMapInteraction);
+            context.register(contextMapBoardToolbarExtension);
+        }
+    }
+}
+/**
+ * Context Map creation tooling — independently flag-gated
+ * (`ddd-context-map`): the senior toolbar button, its palette and the
+ * validation rules, profiles and quality nudges. Both halves are tooling: a map
+ * drawn while the flag was on keeps rendering when it goes off, it just stops
+ * being checked — and the profile it was put on stays written, unread, until the
+ * flag comes back.
  *
  * Note: its Templates-panel category is registered by the aggregate package's
  * {@link DddTemplatesViewExtension} (gated by `ddd-templates`), so templates
@@ -22,6 +66,20 @@ export class DddContextMapViewExtension extends ViewExtensionProvider {
     setup(context) {
         super.setup(context);
         if (this.isEdgeless(context.scope)) {
+            context.register(ValidationRuleExtension(CONTEXT_MAP_RULES));
+            context.register(ValidationProfileExtension(CONTEXT_MAP_PROFILES));
+            context.register(QualityNudgeExtension(CONTEXT_MAP_NUDGES));
+            // The Validation dropdown on a selected board's contextual toolbar. A
+            // SECOND module on the same element, through the `custom:` flavour slot:
+            // `contextMapBoardToolbarExtension` is registered always-on because a
+            // stored board must keep its resize toggle, while choosing how hard to
+            // check it is tooling and belongs here. The config names no framework —
+            // it reads roles and profiles — so it is the very same object Wardley
+            // registers on its own flavour.
+            context.register(ToolbarModuleExtension({
+                id: BlockFlavourIdentifier('custom:affine:surface:contextMap'),
+                config: validationToolbarConfig,
+            }));
             context.register(contextMapSeniorTool);
             context.register(CommandExtension(contextMapCommands, contextMapCommandIcons));
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-ddd-context-map",
   "description": "Labre ddd-context-map framework for @formicoidea/labre-core.",
-  "version": "0.32.0",
+  "version": "0.34.1",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -21,14 +21,18 @@
     "./descriptor": {
       "types": "./dist/descriptor.d.ts",
       "import": "./dist/descriptor.js"
+    },
+    "./commands-manifest": {
+      "types": "./dist/commands-manifest.d.ts",
+      "import": "./dist/commands-manifest.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.32.0",
-    "@formicoidea/labre-ddd-shared": "0.32.0",
+    "@formicoidea/labre-core": "0.34.1",
+    "@formicoidea/labre-ddd-shared": "0.34.1",
     "lit": "^3.2.0"
   }
 }