@formicoidea/labre-ddd-shared 0.40.0 → 0.41.0

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from './shared/prefabs.js';
 export * from './shared/utils.js';
 export * from './toolbar/icons.js';
 export { DddSeniorButtonBase } from './toolbar/senior-buttons.js';
+export * from './translations.js';

package/dist/index.js

@@ -4,3 +4,4 @@ export * from './shared/prefabs.js';
 export * from './shared/utils.js';
 export * from './toolbar/icons.js';
 export { DddSeniorButtonBase } from './toolbar/senior-buttons.js';
+export * from './translations.js';

package/dist/shared/consts.d.ts

@@ -3,6 +3,20 @@
  * (sticky, dot, bubble, connector, label) from these presets — no duplicated
  * component definitions across the Event Storming / Context Map / Core Domain
  * sub-menus.
+ *
+ * ## Where each preset's `label` actually gets a key
+ *
+ * Not here: this file is generic across the three frameworks and declares no
+ * `com.labre.*` key of its own. Every preset below is reused, byte for byte,
+ * as the `labelFallback` of the placement (or connector-arming) command it
+ * feeds in its framework's own `commands.ts` — `ddd-context-map.add<Kind>`,
+ * `ddd-core-domain.<preset>`, `ddd-event-storming.<preset>` — which is where
+ * the command's own `labelKey` (`com.labre.commands.<framework>.<id>`) lives.
+ * `getCommands()` walks registered commands into the translation manifest
+ * automatically ("declared data", see
+ * `packages/affine/shared/src/services/translation-service/README.md`), so a
+ * second key here for the same English word would only be the drift the
+ * manifest guard exists to catch.
  */
 /** Square sticky side (px, canvas reference). */
 export declare const STICKY_SIZE = 120;

package/dist/shared/consts.js

@@ -4,6 +4,20 @@ import { NOTATION_NEUTRALS } from '@formicoidea/labre-core/shared/consts';
  * (sticky, dot, bubble, connector, label) from these presets — no duplicated
  * component definitions across the Event Storming / Context Map / Core Domain
  * sub-menus.
+ *
+ * ## Where each preset's `label` actually gets a key
+ *
+ * Not here: this file is generic across the three frameworks and declares no
+ * `com.labre.*` key of its own. Every preset below is reused, byte for byte,
+ * as the `labelFallback` of the placement (or connector-arming) command it
+ * feeds in its framework's own `commands.ts` — `ddd-context-map.add<Kind>`,
+ * `ddd-core-domain.<preset>`, `ddd-event-storming.<preset>` — which is where
+ * the command's own `labelKey` (`com.labre.commands.<framework>.<id>`) lives.
+ * `getCommands()` walks registered commands into the translation manifest
+ * automatically ("declared data", see
+ * `packages/affine/shared/src/services/translation-service/README.md`), so a
+ * second key here for the same English word would only be the drift the
+ * manifest guard exists to catch.
  */
 /** Square sticky side (px, canvas reference). */
 export const STICKY_SIZE = 120;

package/dist/shared/legend-auto.d.ts

@@ -53,20 +53,43 @@ export interface AutoLegendEntry {
      * off when the parent row is a fair summary of the whole family.
      */
     exact?: boolean;
+    /**
+     * Static prefix kept literal in front of the role's resolved wording — the
+     * Context Map relationship abbreviation ("PS — Partnership"). Absent for
+     * every other row, whose label IS the role's own wording and nothing else.
+     */
+    labelPrefix?: string;
 }
 export interface AutoLegendSectionSpec {
     /** Sub-title, dropped along with the section when none of its rows appear. */
     title?: string;
+    /**
+     * i18n key for {@link title}, resolved through the host's catalogue at
+     * legend-build time when present. Absent for the sections whose title is
+     * generic chrome rather than a framework's own word (`'Legend'`, `'Flow'`…),
+     * which this lot leaves as they are.
+     */
+    titleKey?: string;
     entries: readonly AutoLegendEntry[];
 }
 export interface AutoLegendSpec {
     /**
-     * Box title. The three DDD tools all say "Legend" (PO recette, 26/08/2026:
-     * the boxes used to be titled in French, which was the one label in the
-     * library that was — identifiers and fallback wordings are English here, and
-     * the day a host ships a locale pack it translates a key, not a leftover).
+     * Box title. Every framework with an automatic legend says "Legend" (PO
+     * recette, 26/08/2026: the boxes used to be titled in French, which was the
+     * one label in the library that was — identifiers and fallback wordings are
+     * English here, and the day a host ships a locale pack it translates a key,
+     * not a leftover).
      */
     title: string;
+    /**
+     * i18n key for {@link title}, resolved through the host's catalogue at
+     * legend-build time — the same mechanism as
+     * {@link AutoLegendSectionSpec.titleKey}, one level up. Every framework that
+     * says "Legend" reuses `BOARD_LEGEND_TITLE`
+     * (`@labre/affine-shared/services`), since it is the SAME word on every
+     * board that has one — the three DDD boards, EDGY and C4 alike.
+     */
+    titleKey?: string;
     width?: number;
     /**
      * The framework's role vocabulary, so a present role is matched against an
@@ -84,6 +107,11 @@ export interface AutoLegendSpec {
  * A legend row about `es:flow` says "Flow" because that is what the role def
  * says it is called — the table below never restates a label the vocabulary
  * already owns, so renaming a role renames its legend row.
+ *
+ * This is the FALLBACK half only — the English wording a spec bakes in at
+ * declaration time, with no `std` in scope to ask a host's catalogue. The
+ * catalogue is asked afterwards, once, when the legend is actually drawn: see
+ * {@link autoLegendSections}.
  */
 export declare function roleLabel(roles: RoleDefs, id: RoleId): string;
 /**
@@ -105,8 +133,13 @@ export declare function rolesInBound(gfx: GfxController, bound: Bound): Set<Role
  * "Legend" title and no rows), and it is the honest one — a legend of a board
  * with nothing on it lists nothing, rather than inventing the full notation the
  * user has not used.
+ *
+ * `std` resolves each surviving row's label — and each section's title, where
+ * one carries a {@link AutoLegendSectionSpec.titleKey} — through the host's
+ * catalogue (see {@link resolveRowLabel}); a spec whose entries carry no
+ * `labelKey` at all renders byte-identical to what it always has.
  */
-export declare function autoLegendSections(present: ReadonlySet<RoleId>, spec: AutoLegendSpec): LegendSection[];
+export declare function autoLegendSections(present: ReadonlySet<RoleId>, spec: AutoLegendSpec, std: BlockStdScope): LegendSection[];
 /**
  * Build the legend of what is drawn inside `background` and drop it bottom-left
  * of it, grouped and selected.

package/dist/shared/legend-auto.js

@@ -1,3 +1,4 @@
+import { translateKey } from '@formicoidea/labre-core/shared/services';
 import { Bound } from '@formicoidea/labre-core/global/gfx';
 import { GfxControllerIdentifier, roleIsA, } from '@formicoidea/labre-core/std/gfx';
 import { addLegend, measureLegend, } from './prefabs.js';
@@ -7,10 +8,53 @@ import { addLegend, measureLegend, } from './prefabs.js';
  * A legend row about `es:flow` says "Flow" because that is what the role def
  * says it is called — the table below never restates a label the vocabulary
  * already owns, so renaming a role renames its legend row.
+ *
+ * This is the FALLBACK half only — the English wording a spec bakes in at
+ * declaration time, with no `std` in scope to ask a host's catalogue. The
+ * catalogue is asked afterwards, once, when the legend is actually drawn: see
+ * {@link autoLegendSections}.
  */
 export function roleLabel(roles, id) {
     return roles[id]?.labelFallback ?? id;
 }
+/**
+ * Resolve one row's label through the host's catalogue, at legend-BUILD time
+ * — the one point in this module that has a `std` to ask.
+ *
+ * A row's `label` is baked at spec-declaration time (module scope, no `std`)
+ * as the exact English text a catalogue-less playground must keep showing —
+ * see {@link roleLabel}. Here, if the row's own role carries a `labelKey`, that
+ * baked text becomes the FALLBACK argument of `translateKey` rather than the
+ * final word: a host with a catalogue entry for the key overrides it, and a
+ * host with none gets back the identical string, letter for letter.
+ *
+ * `labelPrefix` rows (the Context Map relationship abbreviations, "PS —
+ * Partnership") are the one case where the row's baked text is not what gets
+ * handed to the catalogue: the role's own `labelFallback` is (the abbreviation
+ * itself is never a translatable word), and the prefix is stitched back on
+ * after translation.
+ */
+function resolveRowLabel(std, roles, entry) {
+    const def = roles[entry.role];
+    if (!def?.labelKey)
+        return entry.row.label;
+    if (entry.labelPrefix) {
+        const translated = translateKey(std, def.labelKey, def.labelFallback ?? entry.role);
+        return `${entry.labelPrefix} — ${translated}`;
+    }
+    return translateKey(std, def.labelKey, entry.row.label);
+}
+/**
+ * Resolve one section's title through the host's catalogue — see
+ * {@link resolveRowLabel}. Absent {@link AutoLegendSectionSpec.titleKey} keeps
+ * the section's title exactly as declared, unresolved: most section titles are
+ * generic chrome ("Legend", "Flow") this lot leaves untranslated.
+ */
+function resolveSectionTitle(std, section) {
+    return section.titleKey && section.title !== undefined
+        ? translateKey(std, section.titleKey, section.title)
+        : section.title;
+}
 /**
  * Distance from the background's left edge / bottom edge, in model units.
  * Wardley's numbers, kept identical so the two gestures put the box in the same
@@ -44,17 +88,25 @@ export function rolesInBound(gfx, bound) {
  * "Legend" title and no rows), and it is the honest one — a legend of a board
  * with nothing on it lists nothing, rather than inventing the full notation the
  * user has not used.
+ *
+ * `std` resolves each surviving row's label — and each section's title, where
+ * one carries a {@link AutoLegendSectionSpec.titleKey} — through the host's
+ * catalogue (see {@link resolveRowLabel}); a spec whose entries carry no
+ * `labelKey` at all renders byte-identical to what it always has.
  */
-export function autoLegendSections(present, spec) {
+export function autoLegendSections(present, spec, std) {
     const sections = [];
     for (const section of spec.sections) {
         const rows = section.entries
             .filter(entry => entry.exact
             ? present.has(entry.role)
             : [...present].some(role => roleIsA(role, entry.role, spec.roles)))
-            .map(entry => entry.row);
+            .map(entry => ({
+            ...entry.row,
+            label: resolveRowLabel(std, spec.roles, entry),
+        }));
         if (rows.length)
-            sections.push({ title: section.title, rows });
+            sections.push({ title: resolveSectionTitle(std, section), rows });
     }
     return sections;
 }
@@ -70,10 +122,13 @@ export function createAutoLegend(std, background, spec) {
     if (!surface)
         return undefined;
     const bound = Bound.deserialize(background.xywh);
-    const sections = autoLegendSections(rolesInBound(gfx, bound), spec);
+    const sections = autoLegendSections(rolesInBound(gfx, bound), spec, std);
+    const title = spec.titleKey
+        ? translateKey(std, spec.titleKey, spec.title)
+        : spec.title;
     const { height } = measureLegend(sections, spec.width);
     std.store.captureSync();
-    const id = addLegend(surface, std, bound.x + INSET_X, bound.y + bound.h - INSET_BOTTOM - height, { title: spec.title, sections, width: spec.width });
+    const id = addLegend(surface, std, bound.x + INSET_X, bound.y + bound.h - INSET_BOTTOM - height, { title, sections, width: spec.width });
     gfx.selection.set({ elements: [id], editing: false });
     return id;
 }

package/dist/translations.d.ts

@@ -0,0 +1,59 @@
+import type { ChromeWording } from '@formicoidea/labre-core/shared/services';
+import type { TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
+/**
+ * The i18n key an Event Storming sticky's default label is asked of the
+ * host's catalogue under, for the given `ES_STICKIES` / hotspot kind.
+ * Exported so `ddd-event-storming/commands.ts` derives the SAME key at
+ * placement rather than restating the derivation.
+ */
+export declare const esStickySeedKey: (kind: string) => string;
+/**
+ * The i18n key a Team Topologies marker's default label is asked of the
+ * host's catalogue under, for the given `TEAM_TOPOLOGIES` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export declare const teamTopologySeedKey: (kind: string) => string;
+/**
+ * The i18n key a Core Domain dot's default label is asked of the host's
+ * catalogue under, for the given `CD_SUBDOMAINS` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export declare const cdSubdomainSeedKey: (kind: string) => string;
+/**
+ * The seeds baked into an Event Storming sticky at creation
+ * (`ddd-event-storming/commands.ts`), derived from the shared palette rather
+ * than restated — a tenth sticky kind added to {@link ES_STICKIES} gets its
+ * seed key with no edit here.
+ *
+ * This TABLE lives in `ddd-shared` because the palette it is derived from
+ * does; the KEYS still name the framework whose creation action actually
+ * writes the text, matching `com.labre.<framework>.seed.<slug>` — nothing here
+ * invents a "ddd-shared" framework.
+ */
+export declare const ES_STICKY_SEEDS: ChromeWording[];
+/**
+ * The seed baked into a Team Topologies interaction-mode marker at creation
+ * (`ddd-core-domain/commands.ts`), derived from {@link TEAM_TOPOLOGIES}.
+ */
+export declare const TEAM_TOPOLOGY_SEEDS: ChromeWording[];
+/**
+ * The seed baked into a Core Domain sub-domain / bounded-context dot at
+ * creation (`ddd-core-domain/commands.ts`), derived from {@link CD_SUBDOMAINS}.
+ */
+export declare const CD_SUBDOMAIN_SEEDS: ChromeWording[];
+/**
+ * Every seed derived from a palette THIS package owns, regardless of which DDD
+ * framework's creation action writes it. `ddd-shared` carries no
+ * `…TranslationEntries` of its own (it registers no command, no role, nothing
+ * the manifest walks) — each of the frameworks above spreads this WHOLE list
+ * into its own `…TranslationEntries` (`mergeTranslationEntries` de-duplicates
+ * the ones it does not use), which is what keeps a DDD framework from ever
+ * importing another one just to reach a shared table.
+ *
+ * Not `TEAM_TOPOLOGIES` / `CD_SUBDOMAINS`-only or `ES_STICKIES`-only: a
+ * framework that does not use a slice of this table today may tomorrow (a
+ * Context Map that starts drawing Team Topologies markers, say), and the
+ * manifest test only cares that every entry here is used by SOME source file —
+ * never that every framework that lists it also uses it.
+ */
+export declare const dddSharedTranslationEntries: TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -0,0 +1,70 @@
+import { CD_SUBDOMAINS, ES_HOTSPOT, ES_STICKIES, TEAM_TOPOLOGIES, } from './shared/consts.js';
+/**
+ * camelCase → kebab-case, the same WS2 derivation each framework's own role
+ * table uses (see `ddd-event-storming/roles.ts`'s `kebab`).
+ */
+const kebab = (kind) => kind.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+/**
+ * The i18n key an Event Storming sticky's default label is asked of the
+ * host's catalogue under, for the given `ES_STICKIES` / hotspot kind.
+ * Exported so `ddd-event-storming/commands.ts` derives the SAME key at
+ * placement rather than restating the derivation.
+ */
+export const esStickySeedKey = (kind) => `com.labre.ddd-event-storming.seed.${kebab(kind)}`;
+/**
+ * The i18n key a Team Topologies marker's default label is asked of the
+ * host's catalogue under, for the given `TEAM_TOPOLOGIES` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export const teamTopologySeedKey = (kind) => `com.labre.ddd-core-domain.seed.${kind}`;
+/**
+ * The i18n key a Core Domain dot's default label is asked of the host's
+ * catalogue under, for the given `CD_SUBDOMAINS` kind. Exported so
+ * `ddd-core-domain/commands.ts` derives the SAME key at placement.
+ */
+export const cdSubdomainSeedKey = (kind) => `com.labre.ddd-core-domain.seed.${kebab(kind)}`;
+/**
+ * The seeds baked into an Event Storming sticky at creation
+ * (`ddd-event-storming/commands.ts`), derived from the shared palette rather
+ * than restated — a tenth sticky kind added to {@link ES_STICKIES} gets its
+ * seed key with no edit here.
+ *
+ * This TABLE lives in `ddd-shared` because the palette it is derived from
+ * does; the KEYS still name the framework whose creation action actually
+ * writes the text, matching `com.labre.<framework>.seed.<slug>` — nothing here
+ * invents a "ddd-shared" framework.
+ */
+export const ES_STICKY_SEEDS = [
+    ...ES_STICKIES.map((preset) => [esStickySeedKey(preset.kind), preset.label]),
+    [esStickySeedKey('hotspot'), ES_HOTSPOT.label],
+];
+/**
+ * The seed baked into a Team Topologies interaction-mode marker at creation
+ * (`ddd-core-domain/commands.ts`), derived from {@link TEAM_TOPOLOGIES}.
+ */
+export const TEAM_TOPOLOGY_SEEDS = TEAM_TOPOLOGIES.map((preset) => [teamTopologySeedKey(preset.kind), preset.label]);
+/**
+ * The seed baked into a Core Domain sub-domain / bounded-context dot at
+ * creation (`ddd-core-domain/commands.ts`), derived from {@link CD_SUBDOMAINS}.
+ */
+export const CD_SUBDOMAIN_SEEDS = CD_SUBDOMAINS.map((preset) => [cdSubdomainSeedKey(preset.kind), preset.label]);
+/**
+ * Every seed derived from a palette THIS package owns, regardless of which DDD
+ * framework's creation action writes it. `ddd-shared` carries no
+ * `…TranslationEntries` of its own (it registers no command, no role, nothing
+ * the manifest walks) — each of the frameworks above spreads this WHOLE list
+ * into its own `…TranslationEntries` (`mergeTranslationEntries` de-duplicates
+ * the ones it does not use), which is what keeps a DDD framework from ever
+ * importing another one just to reach a shared table.
+ *
+ * Not `TEAM_TOPOLOGIES` / `CD_SUBDOMAINS`-only or `ES_STICKIES`-only: a
+ * framework that does not use a slice of this table today may tomorrow (a
+ * Context Map that starts drawing Team Topologies markers, say), and the
+ * manifest test only cares that every entry here is used by SOME source file —
+ * never that every framework that lists it also uses it.
+ */
+export const dddSharedTranslationEntries = [
+    ...ES_STICKY_SEEDS,
+    ...TEAM_TOPOLOGY_SEEDS,
+    ...CD_SUBDOMAIN_SEEDS,
+].map(([key, fallback]) => ({ key, fallback, source: 'seed' }));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-ddd-shared",
   "description": "Labre ddd-shared — shared building blocks for @formicoidea/labre-core frameworks.",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -19,7 +19,7 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.40.0",
+    "@formicoidea/labre-core": "0.41.0",
     "lit": "^3.2.0"
   }
 }