@formicoidea/labre-core 0.41.0 → 0.42.0

package/dist/_pkgs/affine-block-frame/frame-manager.js

@@ -146,7 +146,7 @@ export class EdgelessFrameManager extends GfxExtension {
             .get(EditPropsStore)
             .applyLastProps('affine:frame', {
             // Translated HERE and once: the title is document content the moment
-            // it lands (ADR 0016), so the host's catalogue is asked at placement
+            // it lands (ADR 0023), so the host's catalogue is asked at placement
             // and never again — a renamed frame keeps its name.
             title: new Text(new Y.Text(translateKey(this.gfx.std, ...FRAME_SEED_NAME, {
                 n: this.frames.length + 1,

package/dist/_pkgs/affine-block-frame/frame-tool.js

@@ -50,7 +50,7 @@ export class FrameTool extends BaseTool {
                 .get(EditPropsStore)
                 .applyLastProps('affine:frame', {
                 // Translated HERE and once, like `EdgelessFrameManager._addFrameBlock`:
-                // the title is document content the moment it lands (ADR 0016).
+                // the title is document content the moment it lands (ADR 0023).
                 title: new Text(new Y.Text(translateKey(this.std, ...FRAME_SEED_NAME, {
                     n: frames.length + 1,
                 }))),

package/dist/_pkgs/affine-block-frame/frame-toolbar.js

@@ -1,5 +1,5 @@
 import { EdgelessCRUDIdentifier } from '../affine-block-surface/index.js';
-import { packColor, } from '../affine-components/color-picker/index.js';
+import { frameworkPaletteGroups, packColor, } from '../affine-components/color-picker/index.js';
 import { toast } from '../affine-components/toast/index.js';
 import { DEFAULT_NOTE_HEIGHT, DefaultTheme, FrameBlockModel, FrameBlockSchema, NoteBlockModel, NoteBlockSchema, NoteDisplayMode, resolveColor, SurfaceRefBlockSchema, } from '../affine-model/index.js';
 import { NotificationProvider, TOAST_FRAME_INSERTED_INTO_PAGE, TOOLBAR_RENAME, ToolbarModuleExtension, translateKey, } from '../affine-shared/services/index.js';
@@ -135,6 +135,9 @@ const builtinSurfaceToolbarConfig = {
                             break;
                     }
                 };
+                // A frame drawn over a framework board opens on that framework's hues
+                // (`docs/adr/0027`); the editor palette stays page one.
+                const carousel = frameworkPaletteGroups(ctx.std, models, DefaultTheme.Palettes);
                 return html `
           <edgeless-color-picker-button
             class="background"
@@ -144,6 +147,8 @@ const builtinSurfaceToolbarConfig = {
             .theme=${theme}
             .std=${ctx.std}
             .originalColor=${firstModel.props.background}
+            .paletteGroups=${carousel.groups}
+            .activeGroupKey=${carousel.activeKey}
             .enableCustomColor=${enableCustomColor}
           >
           </edgeless-color-picker-button>

package/dist/_pkgs/affine-block-list/list-keymap.js

@@ -1,6 +1,7 @@
 import { textKeymap } from '../affine-inline-preset/index.js';
 import { ListBlockSchema } from '../affine-model/index.js';
 import { getSelectedModelsCommand } from '../affine-shared/commands/index.js';
+import { isNativeFocusableTarget } from '../affine-shared/utils/index.js';
 import { IS_MAC } from '../global/env/index.js';
 import { KeymapExtension, TextSelection } from '../std/index.js';
 import { canDedentListCommand, dedentListCommand, } from './commands/dedent-list.js';
@@ -11,6 +12,8 @@ import { forwardDelete } from './utils/forward-delete.js';
 export const ListKeymapExtension = KeymapExtension(std => {
     return {
         Enter: ctx => {
+            if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                return;
             const text = std.selection.find(TextSelection);
             if (!text)
                 return false;
@@ -39,6 +42,8 @@ export const ListKeymapExtension = KeymapExtension(std => {
             return true;
         },
         Tab: ctx => {
+            if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                return;
             const [_, { selectedModels }] = std.command
                 .chain()
                 .pipe(getSelectedModelsCommand, {
@@ -63,6 +68,8 @@ export const ListKeymapExtension = KeymapExtension(std => {
             return true;
         },
         'Shift-Tab': ctx => {
+            if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                return;
             const [_, { selectedModels }] = std.command
                 .chain()
                 .pipe(getSelectedModelsCommand, {

package/dist/_pkgs/affine-block-note/note-keymap.js

@@ -1,7 +1,7 @@
 import { CodeBlockModel, ListBlockModel, NoteBlockModel, NoteBlockSchema, ParagraphBlockModel, } from '../affine-model/index.js';
 import { textConversionConfigs } from '../affine-rich-text/index.js';
 import { focusBlockEnd, focusBlockStart, getBlockSelectionsCommand, getNextBlockCommand, getPrevBlockCommand, getTextSelectionCommand, } from '../affine-shared/commands/index.js';
-import { asyncGetBlockComponent, matchModels, } from '../affine-shared/utils/index.js';
+import { asyncGetBlockComponent, isNativeFocusableTarget, matchModels, } from '../affine-shared/utils/index.js';
 import { BlockSelection, KeymapExtension, TextSelection, } from '../std/index.js';
 import { dedentBlocks, dedentBlocksToRoot, indentBlocks, selectBlock, selectBlocksBetween, updateBlockType, } from './commands/index.js';
 import { moveBlockConfigs } from './move-block.js';
@@ -338,6 +338,8 @@ class NoteKeymap {
         };
         this._onEnter = (ctx) => {
             const event = ctx.get('defaultState').event;
+            if (isNativeFocusableTarget(event.target))
+                return;
             const [result] = this._std.command
                 .chain()
                 .pipe(getBlockSelectionsCommand)
@@ -448,6 +450,8 @@ class NoteKeymap {
             ...this._bindQuickActionHotKey(),
             ...this._bindTextConversionHotKey(),
             Tab: ctx => {
+                if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                    return;
                 const [success] = this.std.command.exec(indentBlocks);
                 if (!success)
                     return;
@@ -455,6 +459,8 @@ class NoteKeymap {
                 return true;
             },
             'Shift-Tab': ctx => {
+                if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                    return;
                 const [success] = this.std.command.exec(dedentBlocks);
                 if (!success)
                     return;

package/dist/_pkgs/affine-block-paragraph/paragraph-keymap.js

@@ -1,7 +1,7 @@
 import { textKeymap } from '../affine-inline-preset/index.js';
 import { CalloutBlockModel, ParagraphBlockModel, ParagraphBlockSchema, } from '../affine-model/index.js';
 import { focusTextModel, getInlineEditorByModel, } from '../affine-rich-text/index.js';
-import { calculateCollapsedSiblings, matchModels, } from '../affine-shared/utils/index.js';
+import { calculateCollapsedSiblings, isNativeFocusableTarget, matchModels, } from '../affine-shared/utils/index.js';
 import { IS_MAC } from '../global/env/index.js';
 import { KeymapExtension, TextSelection } from '../std/index.js';
 import { addParagraphCommand } from './commands/add-paragraph.js';
@@ -76,6 +76,8 @@ export const ParagraphKeymapExtension = KeymapExtension(std => {
             return true;
         },
         Enter: ctx => {
+            if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                return;
             const { store } = std;
             const text = std.selection.find(TextSelection);
             if (!text)
@@ -157,6 +159,8 @@ export const ParagraphKeymapExtension = KeymapExtension(std => {
             return true;
         },
         Tab: ctx => {
+            if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                return;
             const [success] = std.command
                 .chain()
                 .pipe(canIndentParagraphCommand)
@@ -169,6 +173,8 @@ export const ParagraphKeymapExtension = KeymapExtension(std => {
             return true;
         },
         'Shift-Tab': ctx => {
+            if (isNativeFocusableTarget(ctx.get('keyboardState').raw.target))
+                return;
             const [success] = std.command
                 .chain()
                 .pipe(canDedentParagraphCommand)

package/dist/_pkgs/affine-block-root/commands/pivot-commands.js

@@ -8,7 +8,7 @@
  * makes the command usable by the agent surface with no UI at all.
  */
 import { TelemetryProvider } from '../../affine-shared/services/index.js';
-import { FRAMEWORK_IDS, } from '../../std/index.js';
+import { frameworkOfRole, } from '../../std/index.js';
 import { GfxControllerIdentifier, GfxPrimitiveElementModel, } from '../../std/gfx/index.js';
 import { z } from 'zod';
 const PIVOT_DOC_ID = 'pivotDocId';
@@ -58,13 +58,6 @@ function pivotTargets(std, elementIds) {
  * which is bad in a different way.
  */
 const isBindable = (std) => !std.store.readonly;
-/** `'wardley:component'` → `'wardley'`, when that names a real framework. */
-function frameworkOfRole(role) {
-    const namespace = role?.split(':')[0];
-    return FRAMEWORK_IDS.includes(namespace ?? '')
-        ? namespace
-        : undefined;
-}
 /** The single value shared by every target, or `undefined` if they disagree. */
 function unanimous(values) {
     const distinct = new Set(values);

package/dist/_pkgs/affine-block-root/commands/tag-commands.js

@@ -14,7 +14,7 @@
  * tags with no `pivotDocId`, and a `pivotDocId` with no `role`.
  */
 import { TelemetryProvider } from '../../affine-shared/services/index.js';
-import { FRAMEWORK_IDS, } from '../../std/index.js';
+import { frameworkOfRole, } from '../../std/index.js';
 import { GfxControllerIdentifier, GfxPrimitiveElementModel, setElementTag, } from '../../std/gfx/index.js';
 import { z } from 'zod';
 /**
@@ -69,13 +69,6 @@ function tagTargets(std, elementIds) {
  * guard of their own.
  */
 const isQualifiable = (std) => !std.store.readonly;
-/** `'wardley:component'` → `'wardley'`, when that names a real framework. */
-function frameworkOfRole(role) {
-    const namespace = role?.split(':')[0];
-    return FRAMEWORK_IDS.includes(namespace ?? '')
-        ? namespace
-        : undefined;
-}
 /** The single value shared by every target, or `undefined` if they disagree. */
 function unanimous(values) {
     const distinct = new Set(values);

package/dist/_pkgs/affine-block-root/edgeless/edgeless-keyboard.d.ts

@@ -18,6 +18,15 @@ export declare class EdgelessPageKeyboardManager extends PageKeyboardManager {
         toolbarLocked: import("rxjs").Subject<boolean>;
     };
     get std(): import("../../std/index.js").BlockStdScope;
+    /**
+     * The framework sub-menu the toolbar has open, when it has one open.
+     *
+     * Asked of the widget rather than of a service because the popover is not a
+     * tool: it is a transient element the toolbar parks in `activePopper`, and
+     * only the generic command menu answers to the keys below — a colour picker
+     * or a note sub-menu sitting in the same slot keeps its own behaviour.
+     */
+    private get _seniorMenu();
     constructor(rootComponent: EdgelessRootBlockComponent);
     private _bindToggleHand;
     private _delete;

package/dist/_pkgs/affine-block-root/edgeless/edgeless-keyboard.js

@@ -14,6 +14,7 @@ import { TextTool } from '../../affine-gfx-text/index.js';
 import { ConnectorElementModel, EdgelessTextBlockModel, GroupElementModel, LayoutType, MindmapElementModel, NoteBlockModel, NoteDisplayMode, } from '../../affine-model/index.js';
 import { BLOCK_NAME_TEXT, EditPropsStore, TelemetryProvider, translateKey, } from '../../affine-shared/services/index.js';
 import { matchModels } from '../../affine-shared/utils/index.js';
+import { cycleArmedArtefact, EDGELESS_TOOLBAR_WIDGET, EdgelessCommandMenu, } from '../../affine-widget-edgeless-toolbar/index.js';
 import { IS_MAC } from '../../global/env/index.js';
 import { Bound, getCommonBound } from '../../global/gfx/index.js';
 import { SurfaceSelection, TextSelection } from '../../std/index.js';
@@ -33,6 +34,23 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
     get std() {
         return this.rootComponent.std;
     }
+    /**
+     * The framework sub-menu the toolbar has open, when it has one open.
+     *
+     * Asked of the widget rather than of a service because the popover is not a
+     * tool: it is a transient element the toolbar parks in `activePopper`, and
+     * only the generic command menu answers to the keys below — a colour picker
+     * or a note sub-menu sitting in the same slot keeps its own behaviour.
+     */
+    get _seniorMenu() {
+        // A keystroke aimed at a canvas text editor belongs to that editor, open
+        // menu or not — the same condition the shape cycling below already has.
+        if (this.rootComponent.service.selection.editing)
+            return null;
+        const toolbar = this.rootComponent.widgetComponents[EDGELESS_TOOLBAR_WIDGET];
+        const element = toolbar?.activePopper?.element;
+        return element instanceof EdgelessCommandMenu ? element : null;
+    }
     constructor(rootComponent) {
         super(rootComponent);
         this.rootComponent = rootComponent;
@@ -157,8 +175,24 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                     .catch(console.error);
             },
             'Shift-s': () => {
+                // Over an open senior menu the very same keystroke steps backwards
+                // through the artefacts it offers — the shape tool's "previous
+                // variant", applied to the row a framework opened. With an artefact
+                // armed the menu walks the TOOL instead, so the ghost moves with the
+                // highlight.
+                const menu = this._seniorMenu;
+                if (menu) {
+                    menu.cycle(-1);
+                    return;
+                }
                 if (this.rootComponent.service.locked)
                     return;
+                // The same walk with no menu open: the framework's row is what the
+                // armed artefact belongs to, whether or not it is on screen.
+                if (!this.rootComponent.service.selection.editing &&
+                    cycleArmedArtefact(rootComponent.gfx, -1)) {
+                    return;
+                }
                 const controller = rootComponent.gfx.tool.currentTool$.peek();
                 if (this.rootComponent.service.selection.editing ||
                     !(controller instanceof ShapeTool)) {
@@ -265,9 +299,22 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 this._move('ArrowDown');
             },
             ArrowLeft: () => {
+                // Same highlight as Shift+S, spelled the way a row of buttons is
+                // normally walked. The guard also keeps the arrows from nudging the
+                // selection behind a menu the user is reading.
+                const menu = this._seniorMenu;
+                if (menu) {
+                    menu.cycle(-1);
+                    return;
+                }
                 this._move('ArrowLeft');
             },
             ArrowRight: () => {
+                const menu = this._seniorMenu;
+                if (menu) {
+                    menu.cycle(1);
+                    return;
+                }
                 this._move('ArrowRight');
             },
             'Shift-ArrowUp': () => {
@@ -283,6 +330,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 this._move('ArrowRight', true);
             },
             Enter: () => {
+                // A highlighted sub-menu button consumes Enter; with nothing
+                // highlighted the menu takes nothing and the canvas keeps its own.
+                if (this._seniorMenu?.activate())
+                    return;
                 const { service } = rootComponent;
                 const selection = service.selection;
                 const elements = selection.selectedElements;

package/dist/_pkgs/affine-block-root/edgeless/edgeless-root-block.d.ts

@@ -23,6 +23,28 @@ export declare class EdgelessRootBlockComponent extends BlockComponent<RootBlock
     private _initResizeEffect;
     private _initSlotEffects;
     private _initViewport;
+    /**
+     * A pinch (or ctrl+wheel) that the capture handler below has already turned
+     * into a canvas zoom. The dispatcher's own handler still receives the event
+     * when nothing swallowed it, and must not zoom a second time.
+     */
+    private readonly _pinchZoomed;
+    /**
+     * Ctrl+wheel and trackpad pinch zoom the CANVAS, never the browser page.
+     *
+     * What stops a browser from page-zooming is `preventDefault()`, and the only
+     * handler that calls it hangs off the event dispatcher — a bubble-phase
+     * listener on the editor host. Two kinds of overlay keep it from ever
+     * running: popups portalled out to `document.body` (the event never reaches
+     * the host), and in-host overlays that stop the wheel on purpose so they
+     * scroll instead of the board (the element toolbar, the validation bubble,
+     * the artefact catalogue…). Under either one the page zoomed.
+     *
+     * One capture-phase listener on `document` sees the gesture before all of
+     * them, and it is deliberately narrow: pinches only — a plain wheel still
+     * belongs to whatever is under the pointer — and only inside this editor.
+     */
+    private readonly _onDocumentPinch;
     private _initWheelEvent;
     bindHotKey(keymap: Record<string, UIEventHandler>, options?: {
         global?: boolean;

package/dist/_pkgs/affine-block-root/edgeless/edgeless-root-block.js

@@ -49,6 +49,7 @@ import { css, html } from 'lit';
 import { query } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
 import { EdgelessPageKeyboardManager } from './edgeless-keyboard.js';
+import { pinchZoomAction } from './utils/pinch-zoom.js';
 import { isCanvasElement } from './utils/query.js';
 let EdgelessRootBlockComponent = (() => {
     let _classSuper = BlockComponent;
@@ -268,11 +269,20 @@ let EdgelessRootBlockComponent = (() => {
             });
         }
         _initWheelEvent() {
+            this._disposables.addFromEvent(document, 'wheel', this._onDocumentPinch, {
+                passive: false,
+                capture: true,
+            });
             this._disposables.add(this.std.event.add('wheel', ctx => {
                 const config = this.std.getOptional(EditorSettingProvider)?.setting$;
                 const state = ctx.get('defaultState');
                 const e = state.event;
                 const edgelessScrollZoom = config?.peek().edgelessScrollZoom ?? false;
+                // Already zoomed, on the way down: the default action is cancelled too.
+                if (this._pinchZoomed.has(e)) {
+                    e.stopPropagation();
+                    return;
+                }
                 e.preventDefault();
                 const { viewport } = this.gfx;
                 if (viewport.locked)
@@ -436,6 +446,42 @@ let EdgelessRootBlockComponent = (() => {
             }, this);
             this._resizeObserver = null;
             this.keyboardManager = null;
+            /**
+             * A pinch (or ctrl+wheel) that the capture handler below has already turned
+             * into a canvas zoom. The dispatcher's own handler still receives the event
+             * when nothing swallowed it, and must not zoom a second time.
+             */
+            this._pinchZoomed = new WeakSet();
+            /**
+             * Ctrl+wheel and trackpad pinch zoom the CANVAS, never the browser page.
+             *
+             * What stops a browser from page-zooming is `preventDefault()`, and the only
+             * handler that calls it hangs off the event dispatcher — a bubble-phase
+             * listener on the editor host. Two kinds of overlay keep it from ever
+             * running: popups portalled out to `document.body` (the event never reaches
+             * the host), and in-host overlays that stop the wheel on purpose so they
+             * scroll instead of the board (the element toolbar, the validation bubble,
+             * the artefact catalogue…). Under either one the page zoomed.
+             *
+             * One capture-phase listener on `document` sees the gesture before all of
+             * them, and it is deliberately narrow: pinches only — a plain wheel still
+             * belongs to whatever is under the pointer — and only inside this editor.
+             */
+            this._onDocumentPinch = (e) => {
+                const action = pinchZoomAction(e, this.std.host);
+                if (action === 'ignore')
+                    return;
+                e.preventDefault();
+                if (action === 'swallow')
+                    return;
+                const { viewport } = this.gfx;
+                if (viewport.locked)
+                    return;
+                const rect = this.getBoundingClientRect();
+                const [baseX, baseY] = viewport.toModelCoord(e.clientX - rect.x, e.clientY - rect.y);
+                viewport.setZoom(normalizeWheelDeltaY(e.deltaY, viewport.zoom), new Point(baseX, baseY), true);
+                this._pinchZoomed.add(e);
+            };
             this.#backgroundElm_accessor_storage = __runInitializers(this, _backgroundElm_initializers, null);
             this.#gfxViewportElm_accessor_storage = (__runInitializers(this, _backgroundElm_extraInitializers), __runInitializers(this, _gfxViewportElm_initializers, void 0));
             this.#mountElm_accessor_storage = (__runInitializers(this, _gfxViewportElm_extraInitializers), __runInitializers(this, _mountElm_initializers, null));

package/dist/_pkgs/affine-block-root/edgeless/utils/pinch-zoom.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The class `createSimplePortal` stamps on every portal root it appends to
+ * `document.body` — the only thing a popup rendered OUTSIDE the editor host
+ * still has in common with the editor that opened it.
+ */
+export declare const PORTAL_CLASS = "blocksuite-portal";
+/**
+ * What the edgeless board owes a wheel event seen on `document`, in capture:
+ *
+ * - `ignore`: not a pinch, or not this editor's business — the page keeps it.
+ * - `swallow`: a pinch inside a popup the editor portalled out to
+ *   `document.body`. The browser must not page-zoom, but the board must not
+ *   move either: zooming under an anchored popup leaves it pointing at nothing.
+ * - `zoom`: a pinch inside the editor — the canvas zooms.
+ */
+export type PinchZoomAction = 'ignore' | 'swallow' | 'zoom';
+/**
+ * The whole decision, readable from the event and the host alone so it can be
+ * tested without a live editor.
+ */
+export declare function pinchZoomAction(event: WheelEvent, host: EventTarget): PinchZoomAction;

package/dist/_pkgs/affine-block-root/edgeless/utils/pinch-zoom.js

@@ -0,0 +1,24 @@
+import { isTouchPadPinchEvent } from '../../../affine-shared/utils/index.js';
+/**
+ * The class `createSimplePortal` stamps on every portal root it appends to
+ * `document.body` — the only thing a popup rendered OUTSIDE the editor host
+ * still has in common with the editor that opened it.
+ */
+export const PORTAL_CLASS = 'blocksuite-portal';
+/**
+ * The whole decision, readable from the event and the host alone so it can be
+ * tested without a live editor.
+ */
+export function pinchZoomAction(event, host) {
+    // A plain wheel still belongs to whatever is under the pointer: an
+    // overflowing toolbar, a bubble, a panel. Only the zoom gesture is claimed.
+    if (!isTouchPadPinchEvent(event))
+        return 'ignore';
+    const path = event.composedPath();
+    if (path.includes(host))
+        return 'zoom';
+    if (path.some(node => node instanceof Element && node.classList.contains(PORTAL_CLASS))) {
+        return 'swallow';
+    }
+    return 'ignore';
+}

package/dist/_pkgs/affine-block-root/edgeless/utils/query.js

@@ -43,6 +43,14 @@ export function getCursorMode(edgelessTool) {
             return drawingCursor;
         case 'eraser':
         case 'shape':
+        // The polygon tool is armed long before it draws anything — the first
+        // click only places a corner — so the cursor is the only thing that says
+        // the next click lands on the canvas rather than selecting.
+        case 'polygon':
+        // An armed framework artefact: the ghost says WHAT lands, the crosshair
+        // says WHERE — and it is all there is for an artefact with nothing drawable
+        // to preview (a lone connector).
+        case 'artefact-placement':
         case 'connector':
         case 'frame':
         case 'affine:note':

package/dist/_pkgs/affine-block-root/keyboard/keymap.js

@@ -1,20 +1,5 @@
+import { isNativeFocusableTarget } from '../../affine-shared/utils/index.js';
 import { KeymapExtension } from '../../std/index.js';
-const NATIVE_FOCUSABLE_SELECTOR = 'button, a[href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
-/**
- * The editor host swallows Tab and Shift-Tab so that indentation stays under
- * the control of the block-scoped handlers. That would however trap the focus
- * on the native controls the editor renders (the collapse button of headings
- * and lists, for instance), which then could neither be reached nor left with
- * the keyboard. When the event originates from such a control — and not from
- * editable text — the native tabbing behaviour is let through.
- */
-const isNativeFocusableTarget = (target) => {
-    if (!(target instanceof Element))
-        return false;
-    if (target instanceof HTMLElement && target.isContentEditable)
-        return false;
-    return !!target.closest(NATIVE_FOCUSABLE_SELECTOR);
-};
 export const fallbackKeymap = KeymapExtension(() => {
     return {
         Tab: ctx => {

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

@@ -1,4 +1,4 @@
-import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '../../affine-model/index.js';
+import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, UmlDiagramElementModel, UmlFragmentElementModel, UmlNodeElementModel, UmlPartitionElementModel, UmlRegionElementModel, UmlSubjectElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '../../affine-model/index.js';
 import { SurfaceElementModel } from './base.js';
 export declare const elementsCtorMap: {
     group: typeof GroupElementModel;
@@ -23,8 +23,14 @@ export declare const elementsCtorMap: {
     c4Node: typeof C4NodeElementModel;
     c4Board: typeof C4BoardElementModel;
     c4Boundary: typeof C4BoundaryElementModel;
+    umlNode: typeof UmlNodeElementModel;
+    umlDiagram: typeof UmlDiagramElementModel;
+    umlSubject: typeof UmlSubjectElementModel;
+    umlPartition: typeof UmlPartitionElementModel;
+    umlRegion: typeof UmlRegionElementModel;
+    umlFragment: typeof UmlFragmentElementModel;
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, UmlDiagramElementModel, UmlFragmentElementModel, UmlNodeElementModel, UmlPartitionElementModel, UmlRegionElementModel, UmlSubjectElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
 export declare enum CanvasElementType {
     BRUSH = "brush",
     CONNECTOR = "connector",
@@ -47,7 +53,13 @@ export declare enum CanvasElementType {
     BPMNPOOL = "bpmnPool",
     C4NODE = "c4Node",
     C4BOARD = "c4Board",
-    C4BOUNDARY = "c4Boundary"
+    C4BOUNDARY = "c4Boundary",
+    UMLNODE = "umlNode",
+    UMLDIAGRAM = "umlDiagram",
+    UMLSUBJECT = "umlSubject",
+    UMLPARTITION = "umlPartition",
+    UMLREGION = "umlRegion",
+    UMLFRAGMENT = "umlFragment"
 }
 export type ElementModelMap = {
     ['shape']: ShapeElementModel;
@@ -72,5 +84,11 @@ export type ElementModelMap = {
     ['c4Node']: C4NodeElementModel;
     ['c4Board']: C4BoardElementModel;
     ['c4Boundary']: C4BoundaryElementModel;
+    ['umlNode']: UmlNodeElementModel;
+    ['umlDiagram']: UmlDiagramElementModel;
+    ['umlSubject']: UmlSubjectElementModel;
+    ['umlPartition']: UmlPartitionElementModel;
+    ['umlRegion']: UmlRegionElementModel;
+    ['umlFragment']: UmlFragmentElementModel;
 };
 export declare function isCanvasElementType(type: string): type is CanvasElementType;

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

@@ -1,4 +1,4 @@
-import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '../../affine-model/index.js';
+import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, UmlDiagramElementModel, UmlFragmentElementModel, UmlNodeElementModel, UmlPartitionElementModel, UmlRegionElementModel, UmlSubjectElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '../../affine-model/index.js';
 import { SurfaceElementModel } from './base.js';
 export const elementsCtorMap = {
     group: GroupElementModel,
@@ -23,8 +23,14 @@ export const elementsCtorMap = {
     c4Node: C4NodeElementModel,
     c4Board: C4BoardElementModel,
     c4Boundary: C4BoundaryElementModel,
+    umlNode: UmlNodeElementModel,
+    umlDiagram: UmlDiagramElementModel,
+    umlSubject: UmlSubjectElementModel,
+    umlPartition: UmlPartitionElementModel,
+    umlRegion: UmlRegionElementModel,
+    umlFragment: UmlFragmentElementModel,
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, UmlDiagramElementModel, UmlFragmentElementModel, UmlNodeElementModel, UmlPartitionElementModel, UmlRegionElementModel, UmlSubjectElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
 export var CanvasElementType;
 (function (CanvasElementType) {
     CanvasElementType["BRUSH"] = "brush";
@@ -49,6 +55,12 @@ export var CanvasElementType;
     CanvasElementType["C4NODE"] = "c4Node";
     CanvasElementType["C4BOARD"] = "c4Board";
     CanvasElementType["C4BOUNDARY"] = "c4Boundary";
+    CanvasElementType["UMLNODE"] = "umlNode";
+    CanvasElementType["UMLDIAGRAM"] = "umlDiagram";
+    CanvasElementType["UMLSUBJECT"] = "umlSubject";
+    CanvasElementType["UMLPARTITION"] = "umlPartition";
+    CanvasElementType["UMLREGION"] = "umlRegion";
+    CanvasElementType["UMLFRAGMENT"] = "umlFragment";
 })(CanvasElementType || (CanvasElementType = {}));
 export function isCanvasElementType(type) {
     return type.toLocaleUpperCase() in CanvasElementType;

package/dist/_pkgs/affine-block-surface/extensions/export-svg/command.d.ts

@@ -0,0 +1,23 @@
+import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
+import type { AnyCommandDescriptor, BlockStdScope } from '../../../std/index.js';
+/**
+ * The framework boards in the current canvas selection.
+ *
+ * `FrameworkBackgroundElementModel` is the whole test, and that is the point of
+ * this command: eleven board kinds today — a Wardley map, a BPMN pool, a C4
+ * board and its boundaries, the three DDD boards, Cynefin, Estuarine, the two
+ * EDGY ones — and whatever a framework adds next, because a board IS the class
+ * and nothing about SVG is per framework (ADR 0025).
+ */
+export declare function selectedBoards(std: BlockStdScope): FrameworkBackgroundElementModel[];
+/**
+ * Render the selected board and hand it to the browser.
+ *
+ * ponytail: ONE board per click, the first of the selection. Browsers throttle
+ * (and Safari silently drops) programmatic downloads fired in a burst, so a
+ * selection of three boards would yield one file, two files or three depending
+ * on the browser — a result nobody can read off the gesture. One board, one
+ * file, every time.
+ */
+export declare function exportBoardSvg(std: BlockStdScope): void;
+export declare const exportSvgCommands: AnyCommandDescriptor[];