@formicoidea/labre-core 0.41.0 → 0.43.1

package/dist/_pkgs/affine-block-root/commands/copy-link-commands.js

@@ -0,0 +1,155 @@
+/**
+ * `doc.copyLink` — put the current document's URL on the clipboard, anchored on
+ * whatever is selected.
+ *
+ * The library does not know what a document's address looks like: routing is
+ * the host's, and the seam for it — `GenerateDocUrlProvider` — has shipped
+ * since AFFiNE with **no consumer at all** on either side. This command is the
+ * consumer, and the counterpart of the paste path that already turns a host URL
+ * back into an inline reference (`ParseDocUrlProvider`, read by
+ * `adapters/middlewares/paste.ts`). Copy here, paste there, and the round trip
+ * closes without the library ever spelling a URL.
+ *
+ * It lives in the registry rather than in the host chrome because ADR 0008
+ * makes a command the single source for its keystroke, its palette entry and
+ * its Settings › Shortcuts row. A host-side button would be reachable from none
+ * of the three, and would not fire while the focus is inside the editor.
+ *
+ * Default chord `Mod-Alt-l` (product decision, PR #401 — the gesture users
+ * already know from Notion). NOT `Mod-l`: `Ctrl+L` / `Cmd+L` is the browser's
+ * address bar and never reaches the page, so a default on it would silently do
+ * nothing on the web. `scope: 'global'` so it fires in page mode and on the
+ * canvas alike.
+ *
+ * **`navigator.clipboard` can be absent, not merely refusing.** The Clipboard
+ * API is a secure-context feature: over plain `http://` on anything but
+ * `localhost`, and in a cross-origin iframe with no `clipboard-write`
+ * permission, the `clipboard` property is `undefined` altogether — so reaching
+ * for `writeText` throws a synchronous `TypeError` out of `run` rather than
+ * returning a promise to reject. That is checked before anything is announced:
+ * no copy, no toast, no telemetry, one `console.error` saying why. Announcing a
+ * copy that never happened is the one failure mode worse than doing nothing.
+ *
+ * A clipboard that EXISTS and then rejects (permission denied at the moment of
+ * writing) is a different case and is left as it is: the promise is caught, and
+ * the toast has already been shown — the same optimistic behaviour the inline
+ * link toolbar has always had, kept deliberately so the two copy-a-link
+ * gestures do not answer differently.
+ */
+import { DocModeProvider, GenerateDocUrlProvider, NotificationProvider, TOAST_LINK_COPIED, TelemetryProvider, translateKey, } from '../../affine-shared/services/index.js';
+import { BlockSelection, SurfaceSelection, } from '../../std/index.js';
+/**
+ * Where the link points INSIDE the document, read off the live selection.
+ *
+ * `mode` is not decoration: the reader of these params
+ * (`extractSearchParams`, `adapters/middlewares/paste.ts`) only looks at
+ * `blockIds` / `elementIds` once it has found a valid `mode` in the query
+ * string, so an anchor emitted without one is dropped on the way back in. When
+ * no `DocModeProvider` is registered the anchor is therefore left out entirely
+ * rather than written in a form nothing can read — the link still opens the
+ * document, which is the honest degradation.
+ *
+ * Canvas before prose: a surface selection and a block selection can coexist in
+ * the store (selecting a note on the canvas leaves the page's own selection
+ * behind), and on the canvas the element IS what the user pointed at.
+ *
+ * A caret is deliberately NOT an anchor. `TextSelection` exists the whole time
+ * somebody is typing, so reading it would mean every copy silently points at a
+ * paragraph instead of the document — the opposite of what an unsolicited
+ * keystroke should do.
+ */
+function anchorOf(std) {
+    const mode = std.getOptional(DocModeProvider)?.getEditorMode();
+    if (!mode)
+        return undefined;
+    const elementIds = std.selection
+        .filter(SurfaceSelection)
+        .flatMap(selection => selection.elements);
+    if (elementIds.length)
+        return { mode, elementIds };
+    const blockIds = std.selection
+        .filter(BlockSelection)
+        .map(selection => selection.blockId);
+    if (blockIds.length)
+        return { mode, blockIds };
+    return { mode };
+}
+/**
+ * The seam, or nothing. Read through `getOptional` like every other host seam,
+ * and reported as UNAVAILABLE rather than as a silent no-op: a palette entry
+ * that copies nothing and a shortcut that does nothing are both worse than an
+ * entry that is not there (`docs/integrate/04-host-seams.md`, step 2 of "How to
+ * add a seam").
+ */
+const canCopyDocLink = (std) => !!std.getOptional(GenerateDocUrlProvider);
+const copyDocLink = {
+    id: 'doc.copyLink',
+    owner: 'core',
+    kind: 'action',
+    // `com.labre.command.*` like the other keyless-by-intent core commands, not
+    // `com.labre.keyboardShortcuts.*`: this one is a capability that happens to
+    // carry a default chord, and the shortcut namespace would file it as a
+    // keymap row for a translator.
+    labelKey: 'com.labre.command.doc.copy-link',
+    labelFallback: 'Copy document link',
+    descriptionKey: 'com.labre.command.doc.copy-link.description',
+    descriptionFallback: 'Copy a link to this document, anchored on the selection, so it can be ' +
+        'pasted into a text as a reference.',
+    keywords: ['link', 'url', 'share', 'reference'],
+    surfaces: ['palette', 'agent'],
+    scope: 'global',
+    defaultKeys: { mac: ['Mod-Alt-l'], other: ['Mod-Alt-l'] },
+    // Copying an address is legitimate in a read-only document, so nothing here
+    // is gated on `editable`; the only precondition is the seam, which is not
+    // expressible in the serializable union and therefore rides on `when`.
+    availability: 'always',
+    when: canCopyDocLink,
+    run: (std, invocation) => {
+        // The load-bearing half of the gate: `runCommand` consults neither
+        // `availability` nor `when`, so the palette and the agent reach `run`
+        // directly — the same arbitration `tag.set` records.
+        const generator = std.getOptional(GenerateDocUrlProvider);
+        if (!generator)
+            return;
+        const params = anchorOf(std);
+        const url = generator.generateDocUrl(std.store.id, params);
+        // A host may decline — an unsaved document, one it does not route. Nothing
+        // is copied and nothing is announced.
+        if (!url)
+            return;
+        // Not a promise rejection: outside a secure context the property itself is
+        // `undefined`, so this would be a synchronous `TypeError` thrown out of
+        // `run` — and `runCommand` only catches what a returned promise rejects
+        // with, so it would surface as an unhandled error taking the keystroke
+        // down with it. Nothing announced, one line saying why.
+        if (!navigator.clipboard) {
+            console.error('doc.copyLink: no clipboard API — a secure context (https, or ' +
+                'localhost) is required, and an iframe needs `clipboard-write`.');
+            return;
+        }
+        navigator.clipboard.writeText(url).catch(console.error);
+        std
+            .getOptional(NotificationProvider)
+            ?.toast(translateKey(std, ...TOAST_LINK_COPIED));
+        // Self-emitted rather than declared through `CommandDescriptor.telemetry`:
+        // that field routes the bottleneck's reporter onto the three framework
+        // CREATION events and requires a `FrameworkId`, and this command creates
+        // nothing and belongs to no framework. `CopiedLink` is the event the two
+        // other copy-a-link sites already emit (the inline link toolbar, the
+        // iframe embed toolbar); reusing it keeps "links copied" one series.
+        // Ids never cross: the document id and the anchored ids stay here.
+        std.getOptional(TelemetryProvider)?.track('CopiedLink', {
+            page: params?.mode === 'edgeless' ? 'whiteboard editor' : 'doc editor',
+            segment: 'editor',
+            module: invocation.surface,
+            control: invocation.source,
+            type: params?.elementIds?.length
+                ? 'element'
+                : params?.blockIds?.length
+                    ? 'block'
+                    : 'document',
+            result: 'success',
+        });
+    },
+};
+export const copyLinkCommands = [copyDocLink];

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/index.d.ts

@@ -1,5 +1,6 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/copy-link-commands.js';
 export * from './commands/pivot-commands.js';
 export * from './commands/reading-commands.js';
 export * from './commands/tag-commands.js';

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

@@ -1,5 +1,6 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/copy-link-commands.js';
 export * from './commands/pivot-commands.js';
 export * from './commands/reading-commands.js';
 export * from './commands/tag-commands.js';

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-root/view.js

@@ -4,6 +4,7 @@ import { ToolbarModuleExtension, ViewportElementExtension, } from '../affine-sha
 import { BlockFlavourIdentifier, BlockViewExtension, FlavourExtension, CommandExtension, ShortcutKeymapExtension, } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { PageClipboard, ReadOnlyClipboard } from './clipboard/index.js';
+import { copyLinkCommands } from './commands/copy-link-commands.js';
 import { pivotCommands } from './commands/pivot-commands.js';
 import { readingCommands } from './commands/reading-commands.js';
 import { tagCommands } from './commands/tag-commands.js';
@@ -70,6 +71,7 @@ export class RootViewExtension extends ViewExtensionProvider {
                 ...pivotCommands,
                 ...tagCommands,
                 ...readingCommands,
+                ...copyLinkCommands,
             ]),
             ShortcutKeymapExtension('global'),
             ToolbarModuleExtension({

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[];