@formicoidea/labre-framework-wardley 0.31.0 → 0.32.0

package/dist/toolbar/wardley-menu.js

@@ -1,144 +1,16 @@
 import { EmptyTool } from '@formicoidea/labre-core/gfx/pointer';
-import { EdgelessToolbarToolMixin } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
-import { css, html, LitElement } from 'lit';
-import { activateWardleyConnector, createWardleyBackground, createWardleyInertia, createWardleyMarket, createWardleyNode, createWardleyPipeline, } from '../actions.js';
-import { wardleyAnchorIcon, wardleyArrowIcon, wardleyBackgroundIcon, wardleyBenefitIcon, wardleyComponentIcon, wardleyEcosystemIcon, wardleyInertiaIcon, wardleyLinkIcon, wardleyMarketIcon, wardleyMethodIcon, wardleyEvolutionGradientIcon, wardleyOpportunityIcon, wardleyPipelineIcon, } from './icons.js';
+import { EdgelessCommandMenu } from '@formicoidea/labre-core/widgets/edgeless-toolbar';
 /**
- * The popover that opens above the toolbar for the Wardley toolbox. Each item
- * creates a pre-formatted Wardley object (see `../actions.ts` — the same
- * actions back the wardley keyboard shortcuts).
+ * The popover that opens above the toolbar for the Wardley toolbox.
+ *
+ * Since PF3 it holds no artefact list of its own: {@link EdgelessCommandMenu}
+ * renders whatever `wardleyCommands` declares for the `senior-menu` surface, so
+ * the menu and the shortcut manifest can no longer drift (they did: 13 vs 7).
  */
-export class EdgelessWardleyMenu extends EdgelessToolbarToolMixin(LitElement) {
+export class EdgelessWardleyMenu extends EdgelessCommandMenu {
     constructor() {
         super(...arguments);
+        this.owner = 'wardley';
         this.type = EmptyTool;
-        this._createInertia = () => {
-            createWardleyInertia(this.gfx);
-        };
-        this._createPipeline = () => {
-            createWardleyPipeline(this.gfx);
-        };
-        this._createMarket = () => {
-            createWardleyMarket(this.gfx);
-        };
-    }
-    static { this.styles = css `
-    :host {
-      display: flex;
-      z-index: -1;
-      justify-content: center;
-    }
-    .menu-content {
-      display: flex;
-      align-items: center;
-      justify-content: center;
-    }
-    .button-group-container {
-      display: flex;
-      align-items: center;
-      gap: 14px;
-      fill: var(--affine-icon-color);
-    }
-    .button-group-container svg {
-      width: 24px;
-      height: 24px;
-    }
-  `; }
-    _createBackground(variant = 'classic') {
-        createWardleyBackground(this.gfx, variant);
-    }
-    _createNode(kind) {
-        createWardleyNode(this.gfx, kind);
-    }
-    _activateConnector(kind) {
-        activateWardleyConnector(this.gfx, kind);
-    }
-    render() {
-        return html `
-      <edgeless-slide-menu>
-        <div class="menu-content">
-          <div class="button-group-container">
-            <edgeless-tool-icon-button
-              .tooltip=${'Wardley map background'}
-              @click=${() => this._createBackground('classic')}
-            >
-              ${wardleyBackgroundIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Opportunity background (gradient)'}
-              @click=${() => this._createBackground('opportunity')}
-            >
-              ${wardleyOpportunityIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Benefit / Investment background (gradient)'}
-              @click=${() => this._createBackground('benefit')}
-            >
-              ${wardleyBenefitIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Evolution background (Wardley presentation)'}
-              @click=${() => this._createBackground('evolution-gradient')}
-            >
-              ${wardleyEvolutionGradientIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Component'}
-              @click=${() => this._createNode('component')}
-            >
-              ${wardleyComponentIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Component + method'}
-              @click=${() => this._createNode('method')}
-            >
-              ${wardleyMethodIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Market'}
-              @click=${this._createMarket}
-            >
-              ${wardleyMarketIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Ecosystem'}
-              @click=${() => this._createNode('ecosystem')}
-            >
-              ${wardleyEcosystemIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Anchor'}
-              @click=${() => this._createNode('anchor')}
-            >
-              ${wardleyAnchorIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Pipeline'}
-              @click=${this._createPipeline}
-            >
-              ${wardleyPipelineIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Link'}
-              @click=${() => this._activateConnector('link')}
-            >
-              ${wardleyLinkIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Arrow (evolution)'}
-              @click=${() => this._activateConnector('arrow')}
-            >
-              ${wardleyArrowIcon}
-            </edgeless-tool-icon-button>
-            <edgeless-tool-icon-button
-              .tooltip=${'Inertia'}
-              @click=${this._createInertia}
-            >
-              ${wardleyInertiaIcon}
-            </edgeless-tool-icon-button>
-          </div>
-        </div>
-      </edgeless-slide-menu>
-    `;
     }
 }

package/dist/translations.d.ts

@@ -0,0 +1,16 @@
+import { type TranslationKeyManifestEntry } from '@formicoidea/labre-core/std';
+/**
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key Wardley can hand to `TranslationProvider.t`, derived from
+ * the very declarations the editor registers.
+ *
+ * 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-wardley` composes this export into the
+ * catalogue it builds — the same sentence that already holds for
+ * `wardleyCommands`. A manifest that named Wardley from the core side would be
+ * complete in the monorepo and silently 61 % short (107 keys of 175) in the
+ * distribution hosts actually consume.
+ */
+export declare const wardleyTranslationEntries: TranslationKeyManifestEntry[];

package/dist/translations.js

@@ -0,0 +1,24 @@
+import { collectTranslationKeys, commandTranslationEntries, mergeTranslationEntries, } from '@formicoidea/labre-core/std';
+import { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
+import { WARDLEY_BACKGROUND } from './background.js';
+import { wardleyCommands } from './commands.js';
+import { WARDLEY_NUDGES } from './nudges.js';
+import { WARDLEY_PROFILES } from './profiles.js';
+import { WARDLEY_READING } from './reading.js';
+import { WARDLEY_ROLES } from './roles.js';
+import { WARDLEY_RULES } from './rules.js';
+/**
+ * THIS framework's contribution to the translation-key manifest — every
+ * `com.labre.*` key Wardley can hand to `TranslationProvider.t`, derived from
+ * the very declarations the editor registers.
+ *
+ * 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-wardley` composes this export into the
+ * catalogue it builds — the same sentence that already holds for
+ * `wardleyCommands`. A manifest that named Wardley from the core side would be
+ * complete in the monorepo and silently 61 % short (107 keys of 175) in the
+ * distribution hosts actually consume.
+ */
+export const wardleyTranslationEntries = mergeTranslationEntries(commandTranslationEntries(wardleyCommands), collectTranslationKeys('role', WARDLEY_ROLES), collectTranslationKeys('background', WARDLEY_BACKGROUND), collectTranslationKeys('rule', WARDLEY_RULES), collectTranslationKeys('nudge', WARDLEY_NUDGES), collectTranslationKeys('profile', WARDLEY_PROFILES), collectTranslationKeys('audit-criterion', WARDLEY_AUDIT_CRITERIA), collectTranslationKeys('reading', WARDLEY_READING));

package/dist/view.d.ts

@@ -1,4 +1,21 @@
 import { type ViewExtensionContext, ViewExtensionProvider } from '@formicoidea/labre-core/ext-loader';
+/**
+ * Wardley rendering — ALWAYS registered, independent of any flag. Disabling
+ * `wardley` hides only the creation tooling (see {@link WardleyViewExtension});
+ * maps already drawn must still paint, stay selectable, stay editable and keep
+ * their contextual toolbar. See `docs/adr/0009`.
+ */
+export declare class WardleyRenderViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}
+/**
+ * Wardley creation tooling — flag-gated (`wardley`): the senior toolbar button,
+ * its templates category, the edgeless chords (w+c, w+l, ...) and the
+ * validation rules and profiles. Both 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.
+ */
 export declare class WardleyViewExtension extends ViewExtensionProvider {
     name: string;
     effect(): void;

package/dist/view.js

@@ -1,8 +1,18 @@
+import { ReadingProfileExtension, tagsToolbarConfig, validationToolbarConfig, QualityNudgeExtension, ValidationProfileExtension, ValidationRuleExtension, } from '@formicoidea/labre-core/blocks/surface';
+import { AuditCriterionExtension, ToolbarModuleExtension, UniverseTagDefsExtension, } from '@formicoidea/labre-core/shared/services';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { extendTemplateCategory } from '@formicoidea/labre-core/gfx/template';
-import { ShortcutExtension } from '@formicoidea/labre-core/std';
+import { BlockFlavourIdentifier, CommandExtension } from '@formicoidea/labre-core/std';
+import { RoleVocabularyExtension } from '@formicoidea/labre-core/std/gfx';
+import { WARDLEY_AUDIT_CRITERIA } from './audit-criteria.js';
+import { wardleyCommandIcons, wardleyCommands } from './commands.js';
 import { effects } from './effects.js';
-import { wardleyShortcuts } from './shortcuts.js';
+import { WARDLEY_TAG_DEFS } from './natures.js';
+import { WARDLEY_PROFILES } from './profiles.js';
+import { WARDLEY_NUDGES } from './nudges.js';
+import { WARDLEY_READING } from './reading.js';
+import { WARDLEY_ROLES } from './roles.js';
+import { WARDLEY_RULES } from './rules.js';
 import { wardleyTemplateCategory } from './templates/index.js';
 import { WardleyElementRendererExtension } from './element-renderer.js';
 import { WardleyInteraction, WardleyView } from './element-view.js';
@@ -11,6 +21,44 @@ import { WardleyNodeView } from './node/node-view.js';
 import { wardleyNodeToolbarExtension } from './toolbar/node-config.js';
 import { wardleyToolbarExtension } from './toolbar/config.js';
 import { wardleySeniorTool } from './toolbar/senior-tool.js';
+/**
+ * Wardley rendering — ALWAYS registered, independent of any flag. Disabling
+ * `wardley` hides only the creation tooling (see {@link WardleyViewExtension});
+ * maps already drawn must still paint, stay selectable, stay editable and keep
+ * their contextual toolbar. See `docs/adr/0009`.
+ */
+export class WardleyRenderViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-wardley-render-gfx';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(WardleyView);
+        context.register(WardleyElementRendererExtension);
+        context.register(WardleyNodeView);
+        context.register(WardleyNodeRendererExtension);
+        // The role VOCABULARY, always on. A role is written in the document, not in
+        // the tooling: the direction reveal of a typed edge, 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(WARDLEY_ROLES));
+        if (this.isEdgeless(context.scope)) {
+            context.register(WardleyInteraction);
+            context.register(wardleyToolbarExtension);
+            context.register(wardleyNodeToolbarExtension);
+        }
+    }
+}
+/**
+ * Wardley creation tooling — flag-gated (`wardley`): the senior toolbar button,
+ * its templates category, the edgeless chords (w+c, w+l, ...) and the
+ * validation rules and profiles. Both 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.
+ */
 export class WardleyViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -18,24 +66,79 @@ export class WardleyViewExtension extends ViewExtensionProvider {
     }
     effect() {
         super.effect();
+        // Defines the senior button and its menu — tooling-only custom elements.
         effects();
         extendTemplateCategory(wardleyTemplateCategory);
     }
     setup(context) {
         super.setup(context);
-        context.register(WardleyView);
-        context.register(WardleyElementRendererExtension);
-        context.register(WardleyNodeView);
-        context.register(WardleyNodeRendererExtension);
         if (this.isEdgeless(context.scope)) {
-            context.register(WardleyInteraction);
+            context.register(ValidationRuleExtension(WARDLEY_RULES));
+            context.register(ValidationProfileExtension(WARDLEY_PROFILES));
+            // Map quality (PF13.9): the four nudges the tool cannot judge, and
+            // nothing else — the on-demand check-up Wardley used to expose beside
+            // them was dropped on the PO recette of 02/08/2026. The engine keeps the
+            // capability (PF5.14 and its two families), Wardley simply declares no
+            // rule that uses it.
+            context.register(QualityNudgeExtension(WARDLEY_NUDGES));
+            // A1–A3, the level-3 criteria (PF14.1). Registered HERE, beside the rules
+            // and for the same reason: a criterion is tooling, so Wardley switched
+            // 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 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
+            // second pack with another `packId` that merges with this one, with no
+            // library release. All packs must land in this one DI scope — `getAll`
+            // never merges across scopes.
+            context.register(UniverseTagDefsExtension(WARDLEY_TAG_DEFS));
+            // The qualification dropdown on the selected component's toolbar. A
+            // THIRD module on the same element, through a free `custom:` flavour
+            // slot. Generic in shape — it names no framework and builds its sections
+            // from the seeded packs — but parameterized by this framework's role
+            // vocabulary, because ADR 0007 § 2bis deliberately keeps roles out of DI
+            // and there is therefore no way to look up "which vocabulary governs this
+            // element". Registered on the NODE and on the GROUP: one click on a
+            // Wardley component selects the group that holds the circle and its
+            // label, and the role lives on the circle.
+            for (const flavour of [
+                'custom:affine:surface:wardleyNode',
+                'custom:affine:surface:group',
+            ]) {
+                context.register(ToolbarModuleExtension({
+                    id: BlockFlavourIdentifier(flavour),
+                    config: tagsToolbarConfig(WARDLEY_ROLES),
+                }));
+            }
+            // The reversed reading (MF3): what the map says about a component, on
+            // demand. One declaration — the roles, the nature tag, the dependency
+            // edge and the map's own zones, all of them already stated elsewhere in
+            // this framework — is the whole of what makes the generic engine able to
+            // read a Wardley map. The CLICK that triggers it is registered once by
+            // the surface and gated by the presence of this profile, so it goes with
+            // the flag without either side naming the other.
+            context.register(ReadingProfileExtension(WARDLEY_READING));
             context.register(wardleySeniorTool);
-            context.register(wardleyToolbarExtension);
-            context.register(wardleyNodeToolbarExtension);
-            // Edgeless-scoped chords (w+c, w+l, ...). Registering here inherits
-            // both the wardley flag gating and the edgeless-only availability;
-            // the installer is ShortcutKeymapExtension('edgeless') in root.
-            context.register(ShortcutExtension(wardleyShortcuts));
+            // The 13 Wardley commands, ONE registration for both faces: the
+            // enumerable registry the sub-menu renders from, and — through
+            // `toShortcutDescriptor` — the edgeless chords (w+c, w+l, ...).
+            // Registering here inherits both the wardley flag gating and the
+            // edgeless-only availability; the keymap installer is
+            // ShortcutKeymapExtension('edgeless') in root.
+            context.register(CommandExtension(wardleyCommands, wardleyCommandIcons));
         }
     }
 }

package/package.json

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

package/dist/label-layout.d.ts

@@ -1,20 +0,0 @@
-import type { WardleyBackgroundElementModel } from '@formicoidea/labre-core/model';
-/** The editable label fields of a Wardley background. */
-export type WardleyLabelField = 'xAxisTitle' | 'yAxisTitle' | 'evolutionStart' | 'evolutionEnd' | 'visibilityHigh' | 'visibilityLow' | 'phase0' | 'phase1' | 'phase2' | 'phase3';
-/** A label's hit box in element-local coordinates (axis-aligned, padded). */
-export interface WardleyLabelHit {
-    field: WardleyLabelField;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-/**
- * Compute the clickable boxes of every *visible* Wardley label, in the
- * element's local space. Positions are derived from the SAME constants the
- * renderer uses (`MARGIN` / `OFFSETS` / `FONTS`), so the hit boxes track the
- * drawn text. Boxes are padded so double-clicking is forgiving.
- */
-export declare function getWardleyLabelHits(model: WardleyBackgroundElementModel, w: number, h: number): WardleyLabelHit[];
-/** First label whose (padded) box contains the local point, or null. */
-export declare function hitTestWardleyLabel(hits: WardleyLabelHit[], lx: number, ly: number): WardleyLabelHit | null;

package/dist/label-layout.js

@@ -1,72 +0,0 @@
-import { FONTS, MARGIN, OFFSETS } from './consts.js';
-/** Rough per-character advance — only used to size generous hit boxes. */
-const approxTextWidth = (text, fontSize) => Math.max(fontSize, text.length * fontSize * 0.6);
-/**
- * Compute the clickable boxes of every *visible* Wardley label, in the
- * element's local space. Positions are derived from the SAME constants the
- * renderer uses (`MARGIN` / `OFFSETS` / `FONTS`), so the hit boxes track the
- * drawn text. Boxes are padded so double-clicking is forgiving.
- */
-export function getWardleyLabelHits(model, w, h) {
-    const px0 = MARGIN.left;
-    const px1 = w - MARGIN.right;
-    const py0 = MARGIN.top;
-    const py1 = h - MARGIN.bottom;
-    const ex = (r) => px0 + r * (px1 - px0);
-    const pad = 6;
-    const hits = [];
-    // Horizontal label anchored on its text baseline.
-    const addH = (field, text, fontSize, ax, baseline, align) => {
-        const tw = approxTextWidth(text, fontSize);
-        const minX = align === 'right' ? ax - tw : ax;
-        const maxX = align === 'right' ? ax : ax + tw;
-        hits.push({
-            field,
-            minX: minX - pad,
-            maxX: maxX + pad,
-            minY: baseline - fontSize - pad,
-            maxY: baseline + fontSize * 0.3 + pad,
-        });
-    };
-    // Vertical label (drawn rotated -90°), centered on (ax, ay).
-    const addV = (field, text, fontSize, ax, ay) => {
-        const tw = approxTextWidth(text, fontSize);
-        hits.push({
-            field,
-            minX: ax - fontSize - pad,
-            maxX: ax + fontSize * 0.4 + pad,
-            minY: ay - tw / 2 - pad,
-            maxY: ay + tw / 2 + pad,
-        });
-    };
-    if (model.showColumnLabels) {
-        addH('phase0', model.phase0, FONTS.phase, ex(0) + OFFSETS.phasePad, py1 + OFFSETS.phaseBaseline, 'left');
-        addH('phase1', model.phase1, FONTS.phase, ex(0.175) + OFFSETS.phasePad, py1 + OFFSETS.phaseBaseline, 'left');
-        addH('phase2', model.phase2, FONTS.phase, ex(0.4) + OFFSETS.phasePad, py1 + OFFSETS.phaseBaseline, 'left');
-        addH('phase3', model.phase3, FONTS.phase, ex(0.7) + OFFSETS.phasePad, py1 + OFFSETS.phaseBaseline, 'left');
-    }
-    if (model.showXAxis) {
-        addH('xAxisTitle', model.xAxisTitle, FONTS.axis, px1 - OFFSETS.evolutionPadRight, py1 + OFFSETS.phaseBaseline, 'right');
-    }
-    if (model.showCornerLabels) {
-        addH('evolutionStart', model.evolutionStart, FONTS.direction, px0 + OFFSETS.directionPadLeft, py0 + OFFSETS.directionTop, 'left');
-        addH('evolutionEnd', model.evolutionEnd, FONTS.direction, px1 - OFFSETS.directionPadRight, py0 + OFFSETS.directionTop, 'right');
-    }
-    if (model.showYAxis) {
-        addV('yAxisTitle', model.yAxisTitle, FONTS.axis, px0 - OFFSETS.yHug, (py0 + py1) / 2);
-    }
-    if (model.showVisibilityLabels) {
-        addV('visibilityHigh', model.visibilityHigh, FONTS.visibility, px0 - OFFSETS.yHug, py0 + OFFSETS.visibleTop);
-        addV('visibilityLow', model.visibilityLow, FONTS.visibility, px0 - OFFSETS.yHug, py1 - OFFSETS.invisibleBottom);
-    }
-    return hits;
-}
-/** First label whose (padded) box contains the local point, or null. */
-export function hitTestWardleyLabel(hits, lx, ly) {
-    for (const hit of hits) {
-        if (lx >= hit.minX && lx <= hit.maxX && ly >= hit.minY && ly <= hit.maxY) {
-            return hit;
-        }
-    }
-    return null;
-}

package/dist/shortcuts.d.ts

@@ -1,2 +0,0 @@
-import type { ShortcutDescriptor } from '@formicoidea/labre-core/std';
-export declare const wardleyShortcuts: ShortcutDescriptor[];

package/dist/shortcuts.js

@@ -1,37 +0,0 @@
-import { GfxControllerIdentifier } from '@formicoidea/labre-core/std/gfx';
-import { activateWardleyConnector, createWardleyBackground, createWardleyInertia, createWardleyNode, createWardleyPipeline, WARDLEY_SHORTCUT_SOURCE, } from './actions.js';
-/**
- * Wardley canvas chords: press `w`, then the action key. Edgeless-scoped and
- * registered by {@link WardleyViewExtension}, so they only exist when the
- * edgeless editor is mounted AND the `wardley` block flag is enabled. The
- * host can rebind or disable each id via `ShortcutOverrides`.
- *
- * This is the reference pattern for other frameworks: same shape with their
- * own prefix letter, listed in `FRAMEWORK_SHORTCUT_GROUPS` (manifest) and
- * registered via `ShortcutExtension` in their view extension (binding).
- */
-const wardleyShortcut = (id, key, run) => ({
-    id: `wardley.${id}`,
-    labelKey: `com.labre.keyboardShortcuts.wardley.${id}`,
-    defaultKeys: { mac: ['w', key], other: ['w', key] },
-    scope: 'edgeless',
-    owner: 'wardley',
-    handler: std => ctx => {
-        const gfx = std.get(GfxControllerIdentifier);
-        // Never fire while editing text on the canvas.
-        if (gfx.selection.editing)
-            return false;
-        ctx.get('defaultState').event.preventDefault();
-        run(gfx);
-        return true;
-    },
-});
-export const wardleyShortcuts = [
-    wardleyShortcut('addComponent', 'c', gfx => createWardleyNode(gfx, 'component', WARDLEY_SHORTCUT_SOURCE)),
-    wardleyShortcut('linkTool', 'l', gfx => activateWardleyConnector(gfx, 'link', WARDLEY_SHORTCUT_SOURCE)),
-    wardleyShortcut('evolutionArrow', 'a', gfx => activateWardleyConnector(gfx, 'arrow', WARDLEY_SHORTCUT_SOURCE)),
-    wardleyShortcut('addInertia', 'i', gfx => createWardleyInertia(gfx, WARDLEY_SHORTCUT_SOURCE)),
-    wardleyShortcut('addPipeline', 'p', gfx => createWardleyPipeline(gfx, WARDLEY_SHORTCUT_SOURCE)),
-    wardleyShortcut('addMethod', 'm', gfx => createWardleyNode(gfx, 'method', WARDLEY_SHORTCUT_SOURCE)),
-    wardleyShortcut('addBackground', 'b', gfx => createWardleyBackground(gfx, 'classic', WARDLEY_SHORTCUT_SOURCE)),
-];