@formicoidea/labre-core 0.23.3 → 0.24.0

package/dist/_pkgs/affine-block-surface/element-model/index.d.ts

@@ -1,4 +1,4 @@
-import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '../../affine-model/index.js';
+import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '../../affine-model/index.js';
 import { SurfaceElementModel } from './base.js';
 export declare const elementsCtorMap: {
     group: typeof GroupElementModel;
@@ -14,10 +14,11 @@ export declare const elementsCtorMap: {
     edgyNode: typeof EdgyNodeElementModel;
     cynefin: typeof CynefinElementModel;
     estuarine: typeof EstuarineElementModel;
+    coreDomain: typeof CoreDomainChartElementModel;
     bpmnNode: typeof BpmnNodeElementModel;
     bpmnPool: typeof BpmnPoolElementModel;
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
 export declare enum CanvasElementType {
     BRUSH = "brush",
     CONNECTOR = "connector",
@@ -32,6 +33,7 @@ export declare enum CanvasElementType {
     EDGYNODE = "edgyNode",
     CYNEFIN = "cynefin",
     ESTUARINE = "estuarine",
+    COREDOMAIN = "coreDomain",
     BPMNNODE = "bpmnNode",
     BPMNPOOL = "bpmnPool"
 }
@@ -49,6 +51,7 @@ export type ElementModelMap = {
     ['edgyNode']: EdgyNodeElementModel;
     ['cynefin']: CynefinElementModel;
     ['estuarine']: EstuarineElementModel;
+    ['coreDomain']: CoreDomainChartElementModel;
     ['bpmnNode']: BpmnNodeElementModel;
     ['bpmnPool']: BpmnPoolElementModel;
 };

package/dist/_pkgs/affine-block-surface/element-model/index.js

@@ -1,4 +1,4 @@
-import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '../../affine-model/index.js';
+import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '../../affine-model/index.js';
 import { SurfaceElementModel } from './base.js';
 export const elementsCtorMap = {
     group: GroupElementModel,
@@ -14,10 +14,11 @@ export const elementsCtorMap = {
     edgyNode: EdgyNodeElementModel,
     cynefin: CynefinElementModel,
     estuarine: EstuarineElementModel,
+    coreDomain: CoreDomainChartElementModel,
     bpmnNode: BpmnNodeElementModel,
     bpmnPool: BpmnPoolElementModel,
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
 export var CanvasElementType;
 (function (CanvasElementType) {
     CanvasElementType["BRUSH"] = "brush";
@@ -33,6 +34,7 @@ export var CanvasElementType;
     CanvasElementType["EDGYNODE"] = "edgyNode";
     CanvasElementType["CYNEFIN"] = "cynefin";
     CanvasElementType["ESTUARINE"] = "estuarine";
+    CanvasElementType["COREDOMAIN"] = "coreDomain";
     CanvasElementType["BPMNNODE"] = "bpmnNode";
     CanvasElementType["BPMNPOOL"] = "bpmnPool";
 })(CanvasElementType || (CanvasElementType = {}));

package/dist/_pkgs/affine-gfx-ddd/core-domain/consts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Visual constants for the Core Domain Chart background (DDD Crew). Authored in
+ * a fixed reference space (900 × 820) and scaled uniformly to the element bounds
+ * by the renderer. Reproduces the supplied template: two axes (Complexity ×
+ * Business differentiation), Low/High ticks and the translucent Generic /
+ * Supporting / Core zone bands. The "Notation" legend is a separate prefab group.
+ */
+export declare const REF_W = 900;
+export declare const REF_H = 820;
+export declare const COLORS: {
+    readonly axis: "#000000";
+    readonly zoneLabel: "#ffffff";
+    readonly tick: "#777777";
+    readonly title: "#000000";
+};
+/** Translucent zone bands (drawn at 0.6 alpha), back-to-front. */
+export declare const ZONES: ReadonlyArray<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill: string;
+}>;
+/** Zone names (centred): [text, x, y, fontSize]. */
+export declare const ZONE_LABELS: ReadonlyArray<readonly [string, number, number, number]>;
+/** Axis frame: origin (ox, oy) bottom-left, up to `top`, right to `right`. */
+export declare const AXIS: {
+    readonly ox: 60;
+    readonly oy: 770;
+    readonly top: 24;
+    readonly right: 846;
+};

package/dist/_pkgs/affine-gfx-ddd/core-domain/consts.js

@@ -0,0 +1,30 @@
+/**
+ * Visual constants for the Core Domain Chart background (DDD Crew). Authored in
+ * a fixed reference space (900 × 820) and scaled uniformly to the element bounds
+ * by the renderer. Reproduces the supplied template: two axes (Complexity ×
+ * Business differentiation), Low/High ticks and the translucent Generic /
+ * Supporting / Core zone bands. The "Notation" legend is a separate prefab group.
+ */
+export const REF_W = 900;
+export const REF_H = 820;
+export const COLORS = {
+    axis: '#000000',
+    zoneLabel: '#ffffff',
+    tick: '#777777',
+    title: '#000000',
+};
+/** Translucent zone bands (drawn at 0.6 alpha), back-to-front. */
+export const ZONES = [
+    { x: 70, y: 30, w: 150, h: 720, fill: '#b3b3b3' },
+    { x: 220, y: 30, w: 220, h: 720, fill: '#9933ff' },
+    { x: 440, y: 30, w: 400, h: 360, fill: '#4d9900' },
+    { x: 440, y: 390, w: 400, h: 360, fill: '#9933ff' },
+];
+/** Zone names (centred): [text, x, y, fontSize]. */
+export const ZONE_LABELS = [
+    ['Core', 640, 214, 26],
+    ['Supporting', 340, 474, 20],
+    ['Generic', 150, 474, 20],
+];
+/** Axis frame: origin (ox, oy) bottom-left, up to `top`, right to `right`. */
+export const AXIS = { ox: 60, oy: 770, top: 24, right: 846 };

package/dist/_pkgs/affine-gfx-ddd/core-domain/element-renderer.d.ts

@@ -0,0 +1,12 @@
+import { type ElementRenderer } from '../../affine-block-surface/index.js';
+import type { CoreDomainChartElementModel } from '../../affine-model/index.js';
+/**
+ * Canvas renderer for the Core Domain Chart background — the translucent
+ * Generic / Supporting / Core zone bands, the two axes with arrow heads and the
+ * Low/High ticks + zone names. Drawn in the fixed reference space and scaled
+ * uniformly to the element bounds.
+ */
+export declare const coreDomain: ElementRenderer<CoreDomainChartElementModel>;
+export declare const CoreDomainRendererExtension: import("../../store/index.js").ExtensionType & {
+    identifier: import("../../global/di/types.js").ServiceIdentifier<ElementRenderer<CoreDomainChartElementModel>>;
+};

package/dist/_pkgs/affine-gfx-ddd/core-domain/element-renderer.js

@@ -0,0 +1,93 @@
+import { ElementRendererExtension, } from '../../affine-block-surface/index.js';
+import { FONT_FAMILY, refScale } from '../shared/utils';
+import { AXIS, COLORS, REF_H, REF_W, ZONE_LABELS, ZONES } from './consts';
+/**
+ * Canvas renderer for the Core Domain Chart background — the translucent
+ * Generic / Supporting / Core zone bands, the two axes with arrow heads and the
+ * Low/High ticks + zone names. Drawn in the fixed reference space and scaled
+ * uniformly to the element bounds.
+ */
+export const coreDomain = (model, ctx, matrix) => {
+    const [, , w, h] = model.deserializedXYWH;
+    const cx = w / 2;
+    const cy = h / 2;
+    ctx.setTransform(matrix.translateSelf(cx, cy).rotateSelf(model.rotate).translateSelf(-cx, -cy));
+    const { s, ox, oy } = refScale(w, h, REF_W, REF_H);
+    ctx.translate(ox, oy);
+    ctx.scale(s, s);
+    // ── Translucent zone bands ──────────────────────────────────────────
+    if (model.showZones) {
+        ctx.globalAlpha = 0.6;
+        for (const z of ZONES) {
+            ctx.fillStyle = z.fill;
+            ctx.fillRect(z.x, z.y, z.w, z.h);
+        }
+        ctx.globalAlpha = 1;
+    }
+    // ── Axes with arrow heads ───────────────────────────────────────────
+    ctx.strokeStyle = COLORS.axis;
+    ctx.fillStyle = COLORS.axis;
+    ctx.lineWidth = 2;
+    ctx.lineJoin = 'round';
+    // Y axis (up)
+    ctx.beginPath();
+    ctx.moveTo(AXIS.ox, AXIS.oy);
+    ctx.lineTo(AXIS.ox, AXIS.top + 6);
+    ctx.stroke();
+    arrow(ctx, AXIS.ox, AXIS.top, 0);
+    // X axis (right)
+    ctx.beginPath();
+    ctx.moveTo(AXIS.ox, AXIS.oy);
+    ctx.lineTo(AXIS.right - 6, AXIS.oy);
+    ctx.stroke();
+    arrow(ctx, AXIS.right, AXIS.oy, 90);
+    ctx.textBaseline = 'alphabetic';
+    // ── Zone names ──────────────────────────────────────────────────────
+    ctx.textAlign = 'center';
+    for (const [text, x, y, size] of ZONE_LABELS) {
+        ctx.fillStyle = COLORS.zoneLabel;
+        ctx.font = `700 ${size}px ${FONT_FAMILY}`;
+        ctx.fillText(text, x, y);
+    }
+    // ── Axis titles + Low/High ticks ────────────────────────────────────
+    if (model.showLabels) {
+        ctx.fillStyle = COLORS.title;
+        ctx.font = `600 14px ${FONT_FAMILY}`;
+        ctx.save();
+        ctx.translate(28, 400);
+        ctx.rotate(-Math.PI / 2);
+        ctx.fillText('Complexity', 0, 0);
+        ctx.restore();
+        ctx.fillText('Business differentiation', 450, 800);
+        ctx.fillStyle = COLORS.tick;
+        ctx.font = `12px ${FONT_FAMILY}`;
+        // X ticks
+        ctx.fillText('Low', 84, 792);
+        ctx.fillText('High', 838, 792);
+        // Y ticks
+        ctx.save();
+        ctx.translate(48, 758);
+        ctx.rotate(-Math.PI / 2);
+        ctx.fillText('Low', 0, 0);
+        ctx.restore();
+        ctx.save();
+        ctx.translate(38, 44);
+        ctx.rotate(-Math.PI / 2);
+        ctx.fillText('High', 0, 0);
+        ctx.restore();
+    }
+};
+/** Filled triangular arrow head at (x, y); `deg` rotates it (0 = pointing up). */
+function arrow(ctx, x, y, deg) {
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate((deg * Math.PI) / 180);
+    ctx.beginPath();
+    ctx.moveTo(0, 0);
+    ctx.lineTo(-5, 9);
+    ctx.lineTo(5, 9);
+    ctx.closePath();
+    ctx.fill();
+    ctx.restore();
+}
+export const CoreDomainRendererExtension = ElementRendererExtension('coreDomain', coreDomain);

package/dist/_pkgs/affine-gfx-ddd/core-domain/element-view.d.ts

@@ -0,0 +1,11 @@
+import type { CoreDomainChartElementModel } from '../../affine-model/index.js';
+import { GfxElementModelView } from '../../std/gfx/index.js';
+/**
+ * View for the Core Domain Chart background. Registering it ensures
+ * `gfx.view.get(model)` returns a view (required so move / select work).
+ */
+export declare class CoreDomainView extends GfxElementModelView<CoreDomainChartElementModel> {
+    static type: string;
+}
+/** Resize gating: handles hidden unless `model.resizeEnabled` (toolbar toggle). */
+export declare const CoreDomainInteraction: import("../../store/index.js").ExtensionType;

package/dist/_pkgs/affine-gfx-ddd/core-domain/element-view.js

@@ -0,0 +1,20 @@
+import { GfxElementModelView, GfxViewInteractionExtension, } from '../../std/gfx/index.js';
+/**
+ * View for the Core Domain Chart background. Registering it ensures
+ * `gfx.view.get(model)` returns a view (required so move / select work).
+ */
+export class CoreDomainView extends GfxElementModelView {
+    static { this.type = 'coreDomain'; }
+}
+/** Resize gating: handles hidden unless `model.resizeEnabled` (toolbar toggle). */
+export const CoreDomainInteraction = GfxViewInteractionExtension(CoreDomainView.type, {
+    handleResize({ model }) {
+        return {
+            beforeResize({ set }) {
+                if (!model.resizeEnabled) {
+                    set({ allowedHandlers: [] });
+                }
+            },
+        };
+    },
+});

package/dist/_pkgs/affine-gfx-ddd/core-domain/legend.d.ts

@@ -0,0 +1,18 @@
+import { type CoreDomainChartElementModel } from '../../affine-model/index.js';
+import type { BlockStdScope } from '../../std/index.js';
+import { type LegendSection } from '../shared/prefabs';
+/**
+ * Build the Notation legend sections. When `present` is given (a content-aware
+ * scan of the background), only the sub-domain types / team-topology modes /
+ * movement actually used are listed; otherwise the full notation is shown.
+ */
+export declare function coreDomainLegendSections(present?: {
+    fills: Set<string>;
+    movement: boolean;
+}): LegendSection[];
+/**
+ * Insert a content-aware legend next to a Core Domain background: scans the
+ * shapes/connectors inside the background's perimeter and lists only the
+ * notation actually present. Triggered from the element's contextual toolbar.
+ */
+export declare function createCoreDomainLegend(std: BlockStdScope, bg: CoreDomainChartElementModel): void;

package/dist/_pkgs/affine-gfx-ddd/core-domain/legend.js

@@ -0,0 +1,69 @@
+import { ConnectorElementModel, ShapeElementModel, StrokeStyle, } from '../../affine-model/index.js';
+import { Bound } from '../../global/gfx/index.js';
+import { GfxControllerIdentifier } from '../../std/gfx/index.js';
+import { CD_SUBDOMAINS, MOVEMENT_COLOR, TEAM_TOPOLOGIES, } from '../shared/consts';
+import { addLegend } from '../shared/prefabs';
+/**
+ * Build the Notation legend sections. When `present` is given (a content-aware
+ * scan of the background), only the sub-domain types / team-topology modes /
+ * movement actually used are listed; otherwise the full notation is shown.
+ */
+export function coreDomainLegendSections(present) {
+    const has = (c) => !present || present.fills.has(c.toLowerCase());
+    const subRows = CD_SUBDOMAINS.filter(s => has(s.fill)).map(s => ({
+        swatch: 'dot',
+        color: s.fill,
+        label: s.label,
+    }));
+    const ttRows = TEAM_TOPOLOGIES.filter(t => has(t.fill)).map(t => ({
+        swatch: 'square',
+        color: t.fill,
+        letter: t.letter,
+        label: t.label,
+    }));
+    const sections = [];
+    if (subRows.length)
+        sections.push({ title: 'Sub-domains', rows: subRows });
+    if (ttRows.length)
+        sections.push({ title: 'Team topologies', rows: ttRows });
+    if (!present || present.movement) {
+        sections.push({
+            title: 'Movement',
+            rows: [{ swatch: 'line', color: MOVEMENT_COLOR, label: 'Movement over time' }],
+        });
+    }
+    // Content-aware scan found nothing recognizable → fall back to the full legend.
+    if (present && sections.length === 0)
+        return coreDomainLegendSections();
+    return sections;
+}
+/**
+ * Insert a content-aware legend next to a Core Domain background: scans the
+ * shapes/connectors inside the background's perimeter and lists only the
+ * notation actually present. Triggered from the element's contextual toolbar.
+ */
+export function createCoreDomainLegend(std, bg) {
+    const gfx = std.get(GfxControllerIdentifier);
+    const surface = gfx.surface;
+    if (!surface)
+        return;
+    const fills = new Set();
+    let movement = false;
+    for (const el of gfx.getElementsByBound(Bound.deserialize(bg.xywh), {
+        type: 'canvas',
+    })) {
+        if (el instanceof ConnectorElementModel) {
+            if (el.strokeStyle === StrokeStyle.Dash)
+                movement = true;
+        }
+        else if (el instanceof ShapeElementModel) {
+            if (typeof el.fillColor === 'string')
+                fills.add(el.fillColor.toLowerCase());
+        }
+    }
+    const [bx, by, bw] = bg.deserializedXYWH;
+    addLegend(surface, std, bx + bw + 30, by, {
+        title: 'Légende',
+        sections: coreDomainLegendSections({ fills, movement }),
+    });
+}

package/dist/_pkgs/affine-gfx-ddd/core-domain/toolbar-config.d.ts

@@ -0,0 +1 @@
+export declare const coreDomainToolbarExtension: import("../../store/index.js").ExtensionType;

package/dist/_pkgs/affine-gfx-ddd/core-domain/toolbar-config.js

@@ -0,0 +1,45 @@
+import { CoreDomainChartElementModel } from '../../affine-model/index.js';
+import { TelemetryProvider, ToolbarModuleExtension, } from '../../affine-shared/services/index.js';
+import { BlockFlavourIdentifier } from '../../std/index.js';
+import { html } from 'lit';
+import { createCoreDomainLegend } from './legend';
+const legendIcon = html `<svg
+  width="24"
+  height="24"
+  viewBox="0 0 24 24"
+  fill="none"
+  xmlns="http://www.w3.org/2000/svg"
+>
+  <rect x="3" y="4" width="18" height="16" rx="2" stroke="currentColor" stroke-width="1.6" />
+  <circle cx="7" cy="9" r="1.6" fill="currentColor" />
+  <circle cx="7" cy="14" r="1.6" fill="currentColor" />
+  <path d="M11 9 H18 M11 14 H18" stroke="currentColor" stroke-width="1.4" />
+</svg>`;
+/** Contextual toolbar for a selected Core Domain background: insert its legend. */
+const coreDomainToolbarConfig = {
+    actions: [
+        {
+            id: 'a.legend',
+            tooltip: 'Insert legend (notation present in the chart)',
+            icon: legendIcon,
+            run(ctx) {
+                const bg = ctx.getSurfaceModelsByType(CoreDomainChartElementModel)[0];
+                if (!bg)
+                    return;
+                createCoreDomainLegend(ctx.std, bg);
+                ctx.std.getOptional(TelemetryProvider)?.track('FrameworkLegendCreated', {
+                    framework: 'core-domain',
+                    element: 'legend',
+                    page: 'whiteboard editor',
+                    segment: 'element toolbar',
+                    module: 'core-domain toolbar',
+                });
+            },
+        },
+    ],
+    when: ctx => ctx.getSurfaceModelsByType(CoreDomainChartElementModel).length > 0,
+};
+export const coreDomainToolbarExtension = ToolbarModuleExtension({
+    id: BlockFlavourIdentifier('affine:surface:coreDomain'),
+    config: coreDomainToolbarConfig,
+});

package/dist/_pkgs/affine-gfx-ddd/effects.d.ts

@@ -0,0 +1,17 @@
+import { EdgelessDddContextMapMenu } from './toolbar/context-map-menu';
+import { EdgelessDddCoreDomainMenu } from './toolbar/core-domain-menu';
+import { EdgelessDddEventStormingMenu } from './toolbar/event-storming-menu';
+import { EdgelessDddContextMapSeniorButton, EdgelessDddCoreDomainSeniorButton, EdgelessDddEventStormingSeniorButton } from './toolbar/senior-buttons';
+export declare function eventStormingEffects(): void;
+export declare function coreDomainEffects(): void;
+export declare function contextMapEffects(): void;
+declare global {
+    interface HTMLElementTagNameMap {
+        'edgeless-ddd-event-storming-menu': EdgelessDddEventStormingMenu;
+        'edgeless-ddd-event-storming-senior-button': EdgelessDddEventStormingSeniorButton;
+        'edgeless-ddd-core-domain-menu': EdgelessDddCoreDomainMenu;
+        'edgeless-ddd-core-domain-senior-button': EdgelessDddCoreDomainSeniorButton;
+        'edgeless-ddd-context-map-menu': EdgelessDddContextMapMenu;
+        'edgeless-ddd-context-map-senior-button': EdgelessDddContextMapSeniorButton;
+    }
+}

package/dist/_pkgs/affine-gfx-ddd/effects.js

@@ -0,0 +1,21 @@
+import { EdgelessDddContextMapMenu } from './toolbar/context-map-menu';
+import { EdgelessDddCoreDomainMenu } from './toolbar/core-domain-menu';
+import { EdgelessDddEventStormingMenu } from './toolbar/event-storming-menu';
+import { EdgelessDddContextMapSeniorButton, EdgelessDddCoreDomainSeniorButton, EdgelessDddEventStormingSeniorButton, } from './toolbar/senior-buttons';
+/** Define a custom element once (each tool's effect may run more than once). */
+function define(tag, ctor) {
+    if (!customElements.get(tag))
+        customElements.define(tag, ctor);
+}
+export function eventStormingEffects() {
+    define('edgeless-ddd-event-storming-menu', EdgelessDddEventStormingMenu);
+    define('edgeless-ddd-event-storming-senior-button', EdgelessDddEventStormingSeniorButton);
+}
+export function coreDomainEffects() {
+    define('edgeless-ddd-core-domain-menu', EdgelessDddCoreDomainMenu);
+    define('edgeless-ddd-core-domain-senior-button', EdgelessDddCoreDomainSeniorButton);
+}
+export function contextMapEffects() {
+    define('edgeless-ddd-context-map-menu', EdgelessDddContextMapMenu);
+    define('edgeless-ddd-context-map-senior-button', EdgelessDddContextMapSeniorButton);
+}

package/dist/_pkgs/affine-gfx-ddd/index.d.ts

@@ -0,0 +1,2 @@
+export { aggregateTemplateCategory, contextMapTemplateCategory, coreDomainTemplateCategory, eventStormingTemplateCategory, } from './templates/index.js';
+export { DddContextMapViewExtension, DddCoreDomainRenderViewExtension, DddCoreDomainViewExtension, DddEventStormingViewExtension, DddTemplatesViewExtension, } from './view.js';

package/dist/_pkgs/affine-gfx-ddd/index.js

@@ -0,0 +1,2 @@
+export { aggregateTemplateCategory, contextMapTemplateCategory, coreDomainTemplateCategory, eventStormingTemplateCategory, } from './templates/index.js';
+export { DddContextMapViewExtension, DddCoreDomainRenderViewExtension, DddCoreDomainViewExtension, DddEventStormingViewExtension, DddTemplatesViewExtension, } from './view.js';

package/dist/_pkgs/affine-gfx-ddd/shared/consts.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Shared DDD palette and sizes. Every tool composes the same irreducible units
+ * (sticky, dot, bubble, connector, label) from these presets — no duplicated
+ * component definitions across the Event Storming / Context Map / Core Domain
+ * sub-menus.
+ */
+/** Square sticky side (px, canvas reference). */
+export declare const STICKY_SIZE = 120;
+/** Faux drop-shadow offset + colour (a plain offset rect behind the sticky). */
+export declare const SHADOW_OFFSET = 7;
+export declare const SHADOW_COLOR = "#0000002e";
+/** Handwriting marker font, already shipped in the canvas font set. */
+export declare const STICKY_FONT = "blocksuite:surface:Kalam";
+export declare const STICKY_FONT_SIZE = 20;
+export declare const STICKY_RADIUS = 6;
+/** Event Storming sticky palette — DDD Crew / Brandolini colour code. */
+export declare const ES_STICKIES: readonly [{
+    readonly kind: "domainEvent";
+    readonly label: "Domain event";
+    readonly fill: "#F5963B";
+    readonly text: "#5a3000";
+}, {
+    readonly kind: "command";
+    readonly label: "Command";
+    readonly fill: "#5BA3DB";
+    readonly text: "#06304d";
+}, {
+    readonly kind: "actor";
+    readonly label: "Actor";
+    readonly fill: "#FFF1A8";
+    readonly text: "#5a4b00";
+}, {
+    readonly kind: "constraint";
+    readonly label: "Constraint";
+    readonly fill: "#FFD84D";
+    readonly text: "#5a4b00";
+}, {
+    readonly kind: "policy";
+    readonly label: "Policy";
+    readonly fill: "#C9A8E0";
+    readonly text: "#3d1f57";
+}, {
+    readonly kind: "readModel";
+    readonly label: "Read model";
+    readonly fill: "#7ED38A";
+    readonly text: "#14502a";
+}, {
+    readonly kind: "system";
+    readonly label: "External system";
+    readonly fill: "#F6A6C0";
+    readonly text: "#5e1230";
+}];
+/** Hotspot — neon-pink diamond. */
+export declare const ES_HOTSPOT: {
+    label: string;
+    fill: string;
+    text: string;
+};
+/** Context Map bounded-context bubble. */
+export declare const CM_BUBBLE: {
+    fill: string;
+    stroke: string;
+    text: string;
+    w: number;
+    h: number;
+    radius: number;
+};
+/**
+ * Context Map relationship presets (DDD Crew notation). Each is the SAME
+ * connector unit + an abbreviation tag; `upDown` adds U/D markers (upstream →
+ * downstream); `dashed` marks the "no real integration" patterns (Separate
+ * Ways, Big Ball of Mud).
+ */
+export declare const CM_RELATIONSHIPS: readonly [{
+    readonly kind: "partnership";
+    readonly label: "Partnership";
+    readonly abbrev: "PS";
+    readonly upDown: false;
+    readonly dashed: false;
+}, {
+    readonly kind: "sharedKernel";
+    readonly label: "Shared Kernel";
+    readonly abbrev: "SK";
+    readonly upDown: false;
+    readonly dashed: false;
+}, {
+    readonly kind: "customerSupplier";
+    readonly label: "Customer / Supplier";
+    readonly abbrev: "C/S";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "conformist";
+    readonly label: "Conformist";
+    readonly abbrev: "CF";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "acl";
+    readonly label: "Anticorruption Layer";
+    readonly abbrev: "ACL";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "ohs";
+    readonly label: "Open Host Service";
+    readonly abbrev: "OHS";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "publishedLanguage";
+    readonly label: "Published Language";
+    readonly abbrev: "PL";
+    readonly upDown: true;
+    readonly dashed: false;
+}, {
+    readonly kind: "separateWays";
+    readonly label: "Separate Ways";
+    readonly abbrev: "SW";
+    readonly upDown: false;
+    readonly dashed: true;
+}, {
+    readonly kind: "bbom";
+    readonly label: "Big Ball of Mud";
+    readonly abbrev: "BBoM";
+    readonly upDown: false;
+    readonly dashed: true;
+}];
+export declare const CLOUD_VERTICES: number[][];
+export declare const CLOUD: {
+    w: number;
+    h: number;
+    fill: string;
+    stroke: string;
+};
+/** Team Topologies interaction modes (placeable markers + Notation legend). */
+export declare const TEAM_TOPOLOGIES: readonly [{
+    readonly kind: "collaboration";
+    readonly label: "Collaboration";
+    readonly letter: "C";
+    readonly fill: "#99ff99";
+}, {
+    readonly kind: "xaas";
+    readonly label: "X-as-a-Service";
+    readonly letter: "X";
+    readonly fill: "#66b2ff";
+}, {
+    readonly kind: "facilitating";
+    readonly label: "Facilitating";
+    readonly letter: "F";
+    readonly fill: "#ffd84d";
+}];
+export declare const MARKER_SIZE = 30;
+/** Core Domain sub-domain / bounded-context dot presets (colours from template). */
+export declare const CD_SUBDOMAINS: readonly [{
+    readonly kind: "bigBet";
+    readonly label: "Big-bet sub-domain";
+    readonly fill: "#9933ff";
+}, {
+    readonly kind: "platform";
+    readonly label: "Platform sub-domain";
+    readonly fill: "#66b2ff";
+}, {
+    readonly kind: "outsourced";
+    readonly label: "Outsourced / purchased";
+    readonly fill: "#99ff99";
+}, {
+    readonly kind: "bcCurrent";
+    readonly label: "Bounded context";
+    readonly fill: "#ff3333";
+}, {
+    readonly kind: "bcFuture";
+    readonly label: "Future position";
+    readonly fill: "#cccccc";
+}];
+export declare const DOT_SIZE = 26;
+export declare const MOVEMENT_COLOR = "#ff3333";
+export declare const LABEL_COLOR = "#1f2328";
+export declare const LABEL_FONT = "blocksuite:surface:Inter";
+export declare const LABEL_FONT_SIZE = 14;