@formicoidea/labre-core 0.31.0 → 0.32.0

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

@@ -90,6 +90,11 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
             f: () => {
                 if (this.rootComponent.service.locked)
                     return;
+                // `createFrameOnSelected` reaches `store.addBlock`, which throws on
+                // readonly; `_setEdgelessTool` below is guarded too, but the branch
+                // taken depends on the selection, so refuse the whole gesture here.
+                if (this.rootComponent.store.readonly)
+                    return;
                 if (this.rootComponent.service.selection.selectedElements.length !==
                     0 &&
                     !this.rootComponent.service.selection.editing) {
@@ -307,6 +312,9 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 if (!isSingleMindMapNode(elements)) {
                     return;
                 }
+                // `mindmap.addNode` writes through a raw `transact`.
+                if (rootComponent.store.readonly)
+                    return;
                 const mindmap = elements[0].group;
                 const currentNode = mindmap.getNode(elements[0].id);
                 const node = mindmap.getNode(elements[0].id);
@@ -329,6 +337,9 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 if (!isSingleMindMapNode(elements)) {
                     return;
                 }
+                // Same raw-`transact` path as Enter's `addNode`.
+                if (rootComponent.store.readonly)
+                    return;
                 const mindmap = elements[0].group;
                 if (mindmap.isLocked())
                     return;
@@ -368,7 +379,9 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
                 !event.metaKey) {
                 const elements = selection.selectedElements;
                 const doc = this.rootComponent.store;
-                if (isSingleMindMapNode(elements)) {
+                // Raw `transact` on a surface element: readonly-guarded here, since
+                // the store itself does not guard transactions.
+                if (isSingleMindMapNode(elements) && !doc.readonly) {
                     const target = gfx.getElementById(elements[0].id);
                     if (target.text) {
                         doc.transact(() => {
@@ -392,6 +405,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
     }
     _delete() {
         const edgeless = this.rootComponent;
+        // Deletion bypasses the store's block CRUD for canvas elements
+        // (`surface.deleteElement` is a raw `transact`).
+        if (edgeless.store.readonly)
+            return;
         if (edgeless.service.locked)
             return;
         if (edgeless.service.selection.editing) {
@@ -469,6 +486,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
             }
             return;
         }
+        // After the mindmap branch: arrow-key NAVIGATION stays available on a
+        // readonly board, moving elements (raw field writes) does not.
+        if (edgeless.store.readonly)
+            return;
         if (selectedElements.some(e => e.isLocked()))
             return;
         const movedElements = new Set([
@@ -505,6 +526,10 @@ export class EdgelessPageKeyboardManager extends PageKeyboardManager {
         });
     }
     _setEdgelessTool(toolType, ...options) {
+        // No readonly guard here: `gfx.tool.setTool` below is the bottleneck and
+        // carries `READONLY_SAFE_TOOLS` for every entry point, including the ones
+        // that never come through this manager (`s` is bound by
+        // `shape-draggable.ts` straight onto the toolbar mixin).
         const ignoreActiveState = typeof options === 'boolean'
             ? options[0]
             : options[1] === undefined

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

@@ -286,7 +286,12 @@ let EdgelessRootBlockComponent = (() => {
                 }
                 // pan
                 else {
-                    const simulateHorizontalScroll = IS_WINDOWS && e.shiftKey;
+                    // Shift+wheel means "scroll sideways" on every platform. Windows
+                    // never sends a horizontal delta for it, so the vertical one has to
+                    // be reinterpreted; elsewhere the OS does it natively for trackpads
+                    // and horizontal-capable mice, and `deltaX === 0` is what a plain
+                    // mouse — with nothing but a vertical wheel — leaves us to work with.
+                    const simulateHorizontalScroll = e.shiftKey && (IS_WINDOWS || e.deltaX === 0);
                     const dx = simulateHorizontalScroll
                         ? e.deltaY / viewport.zoom
                         : e.deltaX / viewport.zoom;
@@ -305,7 +310,11 @@ let EdgelessRootBlockComponent = (() => {
                     const handler = keymap[key];
                     keymap[key] = ctx => {
                         const elements = selection.selectedElements;
-                        if (isSingleMindMapNode(elements) && !selection.editing) {
+                        // The mindmap branch overwrites the node's text through a raw
+                        // `transact`, which has no readonly guard of its own.
+                        if (isSingleMindMapNode(elements) &&
+                            !selection.editing &&
+                            !this.store.readonly) {
                             const target = gfx.getElementById(elements[0].id);
                             if (target.text) {
                                 this.store.transact(() => {

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

@@ -104,6 +104,15 @@ export class EdgelessRootService extends BlockService {
         this._initReadonlyListener();
     }
     removeElement(id) {
+        // Word-for-word duplicate of `EdgelessCRUDExtension.removeElement`, so it
+        // carries the same guard — see the comment there. Today it is only
+        // reachable through the element toolbar (already inert on readonly), but a
+        // guard-less parallel API is exactly the door the next caller walks
+        // through.
+        if (this.doc.readonly) {
+            console.error('cannot remove element in readonly mode');
+            return;
+        }
         id = typeof id === 'string' ? id : id.id;
         const el = this.crud.getElementById(id);
         if (isGfxGroupCompatibleModel(el)) {
@@ -121,6 +130,11 @@ export class EdgelessRootService extends BlockService {
         }
     }
     reorderElement(element, direction) {
+        // `element.index = …` is a raw transaction on both branches below.
+        if (this.doc.readonly) {
+            console.error('cannot reorder element in readonly mode');
+            return;
+        }
         const index = this.layer.getReorderedIndex(element, direction);
         // block should be updated in transaction
         if (element instanceof GfxBlockElementModel) {

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

@@ -3,6 +3,7 @@ export * from './clipboard/clipboard.js';
 export * from './clipboard/command.js';
 export * from './edgeless-root-block.js';
 export { EdgelessRootService } from './edgeless-root-service.js';
+export { RESERVED_EDGELESS_KEYS, type ReservedEdgelessKey, } from './reserved-keys.js';
 export * from './utils/clipboard-utils.js';
 export { sortEdgelessElements } from './utils/clone-utils.js';
 export { isCanvasElement } from './utils/query.js';

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

@@ -3,6 +3,7 @@ export * from './clipboard/clipboard.js';
 export * from './clipboard/command.js';
 export * from './edgeless-root-block.js';
 export { EdgelessRootService } from './edgeless-root-service.js';
+export { RESERVED_EDGELESS_KEYS, } from './reserved-keys.js';
 export * from './utils/clipboard-utils.js';
 export { sortEdgelessElements } from './utils/clone-utils.js';
 export { isCanvasElement } from './utils/query.js';

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

@@ -0,0 +1,21 @@
+/**
+ * Single-keystroke edgeless bindings owned by imperative code — the raw
+ * `bindHotKey({...})` call in `edgeless-keyboard.ts`, which predates the
+ * shortcut manifest.
+ *
+ * Those bindings are not `ShortcutDescriptor`s, so `resolveKeymap` cannot see
+ * them and cannot report a conflict against them: an EDGY chord on `e` would
+ * silently shadow the eraser. Until they are folded into real descriptors
+ * (sequenced AFTER the PF3 switchover — several of them are stateful cycles,
+ * not commands, so expressing them changes their semantics), this list is what
+ * closes the hole. It is asserted against the real bindings by a mirror test
+ * and checked against every `FrameworkDescriptor.chordPrefix`.
+ *
+ * `Mod-`-prefixed bindings are deliberately absent: a framework chord prefix is
+ * a bare letter, so only the bare-letter bindings can collide with one.
+ *
+ * See `docs/adr/0008` § Reserving the prefix letter. When surface (e) becomes
+ * descriptors, this constant is deleted.
+ */
+export declare const RESERVED_EDGELESS_KEYS: readonly ["v", "t", "c", "h", "n", "p", "Shift-p", "e", "k", "f", "-", "@", "Shift-s"];
+export type ReservedEdgelessKey = (typeof RESERVED_EDGELESS_KEYS)[number];

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

@@ -0,0 +1,34 @@
+/**
+ * Single-keystroke edgeless bindings owned by imperative code — the raw
+ * `bindHotKey({...})` call in `edgeless-keyboard.ts`, which predates the
+ * shortcut manifest.
+ *
+ * Those bindings are not `ShortcutDescriptor`s, so `resolveKeymap` cannot see
+ * them and cannot report a conflict against them: an EDGY chord on `e` would
+ * silently shadow the eraser. Until they are folded into real descriptors
+ * (sequenced AFTER the PF3 switchover — several of them are stateful cycles,
+ * not commands, so expressing them changes their semantics), this list is what
+ * closes the hole. It is asserted against the real bindings by a mirror test
+ * and checked against every `FrameworkDescriptor.chordPrefix`.
+ *
+ * `Mod-`-prefixed bindings are deliberately absent: a framework chord prefix is
+ * a bare letter, so only the bare-letter bindings can collide with one.
+ *
+ * See `docs/adr/0008` § Reserving the prefix letter. When surface (e) becomes
+ * descriptors, this constant is deleted.
+ */
+export const RESERVED_EDGELESS_KEYS = [
+    'v',
+    't',
+    'c',
+    'h',
+    'n',
+    'p',
+    'Shift-p',
+    'e',
+    'k',
+    'f',
+    '-',
+    '@',
+    'Shift-s',
+];

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

@@ -52,4 +52,10 @@ export declare function mapFrameIds(props: FrameBlockProps, ids: Map<string, str
  * @returns updated element props
  */
 export declare function mapMindmapIds(props: SerializedMindmapElement, ids: Map<string, string>): SerializedMindmapElement;
-export declare function getElementProps(element: GfxPrimitiveElementModel, ids: Map<string, string>): SerializedElement;
+/**
+ * @param element the element to serialize
+ * @param ids old element id to new element id map
+ * @param elements the set of elements being cloned, used to detect connector
+ *   endpoints that are left behind
+ */
+export declare function getElementProps(element: GfxPrimitiveElementModel, ids: Map<string, string>, elements: GfxModel[]): SerializedElement;

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

@@ -162,9 +162,18 @@ export function mapMindmapIds(props, ids) {
     }
     return props;
 }
-export function getElementProps(element, ids) {
+/**
+ * @param element the element to serialize
+ * @param ids old element id to new element id map
+ * @param elements the set of elements being cloned, used to detect connector
+ *   endpoints that are left behind
+ */
+export function getElementProps(element, ids, elements) {
     if (element instanceof ConnectorElementModel) {
-        const props = element.serialize();
+        // An endpoint whose element is not part of the cloned set is turned into an
+        // absolute position instead of keeping an id that resolves to nothing in
+        // the target document.
+        const props = serializeConnector(element, elements);
         return mapConnectorIds(props, ids);
     }
     if (element instanceof GroupElementModel) {

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

@@ -1,8 +1,11 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/pivot-commands.js';
+export * from './commands/reading-commands.js';
+export * from './commands/tag-commands.js';
 export * from './edgeless/edgeless-root-spec.js';
 export * from './edgeless/index.js';
-export * from './keyboard/shortcuts.js';
+export * from './keyboard/commands.js';
 export * from './page/page-root-block.js';
 export * from './preview/preview-root-block.js';
 export * from './types.js';

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

@@ -1,8 +1,11 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/pivot-commands.js';
+export * from './commands/reading-commands.js';
+export * from './commands/tag-commands.js';
 export * from './edgeless/edgeless-root-spec.js';
 export * from './edgeless/index.js';
-export * from './keyboard/shortcuts.js';
+export * from './keyboard/commands.js';
 export * from './page/page-root-block.js';
 export * from './preview/preview-root-block.js';
 export * from './types.js';

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

@@ -0,0 +1,2 @@
+import type { CommandDescriptor } from '../../std/index.js';
+export declare const coreCommands: CommandDescriptor[];

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

@@ -0,0 +1,147 @@
+import { EdgelessCRUDIdentifier, getLastPropsKey, } from '../../affine-block-surface/index.js';
+import { EditPropsStore } from '../../affine-shared/services/index.js';
+import { pickStylePropsForKey } from '../../affine-shared/utils/index.js';
+import { IS_WINDOWS } from '../../global/env/index.js';
+import { GfxControllerIdentifier, GfxPrimitiveElementModel, } from '../../std/gfx/index.js';
+import { duplicate } from '../edgeless/utils/clipboard-utils.js';
+/**
+ * Core (always-on) commands, expressed as {@link CommandDescriptor}s.
+ *
+ * They were already rebindable descriptors; PF3 promotes them to the single
+ * source so the keymap, Settings › Shortcuts and the palette read ONE list
+ * (`docs/adr/0008`). Ids, `labelKey`s and `defaultKeys` are carried over
+ * verbatim — persisted v0.29 override tables stay valid.
+ *
+ * They carry no `telemetry`: undo/redo/duplicate emitted nothing before, and
+ * the bottleneck only emits what a descriptor declares.
+ */
+/**
+ * The elements the "apply last style" gesture would actually repaint, with the
+ * schema-filtered props each would receive.
+ *
+ * Computed by the `when` predicate AND by `run`, on purpose: the projection to
+ * a shortcut only consumes the keystroke when `when` holds, and this gesture
+ * must fall through when it has nothing to apply — on Windows `Mod+Y` is also
+ * the `redo-windows` alias, which has to keep working.
+ */
+function lastStyleTargets(std) {
+    // Readonly: nothing to repaint, so `when` fails and the keystroke falls
+    // through (on Windows Mod+Y is also the redo alias, itself readonly-gated).
+    if (std.store.readonly)
+        return [];
+    const gfx = std.get(GfxControllerIdentifier);
+    const lastStyle = std.get(EditPropsStore).lastUsedStyle$.value;
+    if (!Object.keys(lastStyle).length)
+        return [];
+    return gfx.selection.selectedElements.flatMap(element => {
+        const isPrimitive = element instanceof GfxPrimitiveElementModel;
+        const key = getLastPropsKey(isPrimitive ? element.type : element.flavour, (isPrimitive ? element.serialize() : {}));
+        const props = key ? pickStylePropsForKey(key, lastStyle) : null;
+        return props ? [{ id: element.id, props }] : [];
+    });
+}
+export const coreCommands = [
+    {
+        id: 'undo',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.undo',
+        labelFallback: 'Undo',
+        surfaces: ['palette', 'agent'],
+        scope: 'global',
+        defaultKeys: { mac: ['Mod-z'], other: ['Mod-z'] },
+        availability: 'always',
+        run: std => {
+            if (std.store.canUndo)
+                std.store.undo();
+        },
+    },
+    {
+        id: 'redo',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.redo',
+        labelFallback: 'Redo',
+        surfaces: ['palette', 'agent'],
+        scope: 'global',
+        defaultKeys: { mac: ['Shift-Mod-z'], other: ['Shift-Mod-z'] },
+        availability: 'always',
+        run: std => {
+            if (std.store.canRedo)
+                std.store.redo();
+        },
+    },
+    {
+        // Windows-only redo alias (Ctrl+Y); not bound on mac (empty combo).
+        id: 'redo-windows',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.redo',
+        labelFallback: 'Redo',
+        // Not offered as a command: it is a platform alias of `redo`, not a second
+        // capability. It stays bindable in Settings › Shortcuts like every command.
+        surfaces: [],
+        scope: 'global',
+        defaultKeys: { mac: [], other: ['Control-y'] },
+        availability: 'always',
+        when: () => IS_WINDOWS,
+        run: std => {
+            if (std.store.canRedo)
+                std.store.redo();
+        },
+    },
+    {
+        // Duplicate the current edgeless selection. Mod+D is the browser
+        // "add bookmark" gesture, so the projection always preventDefaults when it
+        // acts. On mac Mod resolves to Cmd (Cmd+D = duplicate) which coexists with
+        // the imperative Ctrl+D = delete binding (see `edgeless-keyboard.ts`); on
+        // Windows/Linux Mod resolves to Ctrl (Ctrl+D = duplicate).
+        id: 'duplicate',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.duplicate',
+        labelFallback: 'Duplicate',
+        surfaces: ['palette', 'agent'],
+        scope: 'edgeless',
+        defaultKeys: { mac: ['Mod-d'], other: ['Mod-d'] },
+        availability: 'selection',
+        run: std => {
+            const elements = std.get(GfxControllerIdentifier).selection
+                .selectedElements;
+            const rootId = std.store.root?.id;
+            const edgeless = rootId ? std.view.getBlock(rootId) : null;
+            if (!edgeless)
+                return;
+            duplicate(edgeless, elements).catch(console.error);
+        },
+    },
+    {
+        // Apply the last used style to the selected elements. "Last used" is the
+        // flat accumulation of every style prop the user recorded (every style
+        // edit and style pick records it), across element types: a fill picked on
+        // a rect repaints an ellipse, a font style set on a text restyles a
+        // shape. Each element only receives the props its own type supports —
+        // schema-filtered per prop, so geometry and content are never touched.
+        id: 'applyLastStyle',
+        owner: 'core',
+        kind: 'action',
+        labelKey: 'com.affine.keyboardShortcuts.applyLastStyle',
+        labelFallback: 'Apply last style',
+        surfaces: ['palette', 'agent'],
+        scope: 'edgeless',
+        defaultKeys: { mac: ['Mod-y'], other: ['Mod-y'] },
+        availability: 'selection',
+        when: std => lastStyleTargets(std).length > 0,
+        run: std => {
+            const targets = lastStyleTargets(std);
+            if (!targets.length)
+                return;
+            // One history frame: a single undo restores the previous styles.
+            std.store.captureSync();
+            const crud = std.get(EdgelessCRUDIdentifier);
+            for (const { id, props } of targets) {
+                crud.updateElement(id, props);
+            }
+        },
+    },
+];

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

@@ -1,9 +1,12 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { NoteBlockSchema } from '../affine-model/index.js';
 import { ToolbarModuleExtension, ViewportElementExtension, } from '../affine-shared/services/index.js';
-import { BlockFlavourIdentifier, BlockViewExtension, FlavourExtension, ShortcutExtension, ShortcutKeymapExtension, } from '../std/index.js';
+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 { pivotCommands } from './commands/pivot-commands.js';
+import { readingCommands } from './commands/reading-commands.js';
+import { tagCommands } from './commands/tag-commands.js';
 import { builtinToolbarConfig } from './configs/toolbar.js';
 import { EdgelessClipboardController, EdgelessRootService } from './edgeless/index.js';
 import { EdgelessElementToolbarExtension } from './edgeless/configs/toolbar/index.js';
@@ -11,7 +14,7 @@ import { EdgelessLocker } from './edgeless/edgeless-root-spec.js';
 import { AltCloneExtension } from './edgeless/interact-extensions/clone-ext.js';
 import { effects } from './effects.js';
 import { fallbackKeymap } from './keyboard/keymap.js';
-import { coreShortcuts } from './keyboard/shortcuts.js';
+import { coreCommands } from './keyboard/commands.js';
 export class RootViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -59,9 +62,15 @@ export class RootViewExtension extends ViewExtensionProvider {
         context.register([
             FlavourExtension('affine:page'),
             fallbackKeymap,
-            // Enumerable, host-overridable shortcuts. Core undo/redo live here; the
+            // Enumerable, host-overridable commands. Core undo/redo live here; the
+            // registration also derives their shortcut descriptors, and the
             // installer binds the effective keymap (see `@labre/std` shortcut.ts).
-            ShortcutExtension(coreShortcuts),
+            CommandExtension([
+                ...coreCommands,
+                ...pivotCommands,
+                ...tagCommands,
+                ...readingCommands,
+            ]),
             ShortcutKeymapExtension('global'),
             ToolbarModuleExtension({
                 id: BlockFlavourIdentifier(NoteBlockSchema.model.flavour),

package/dist/_pkgs/affine-block-surface/commands/reassociate-connectors.js

@@ -22,7 +22,6 @@ export const reassociateConnectorsCommand = (ctx, next) => {
                     id: newId,
                 },
             });
-            continue;
         }
         if (target.id === oldId) {
             surface.updateElement(id, {

package/dist/_pkgs/affine-block-surface/effects.js

@@ -1,6 +1,12 @@
+import { MAP_QUALITY_WIDGET, MapQualityWidget, } from './extensions/map-quality-widget.js';
+import { READING_PROPOSAL_WIDGET, ReadingProposalWidget, } from './extensions/reading-widget.js';
+import { VIOLATION_DETAIL_WIDGET, ViolationDetailWidget, } from './extensions/violation-detail-widget.js';
 import { SurfaceBlockComponent } from './surface-block.js';
 import { SurfaceBlockVoidComponent } from './surface-block-void.js';
 export function effects() {
     customElements.define('affine-surface-void', SurfaceBlockVoidComponent);
     customElements.define('affine-surface', SurfaceBlockComponent);
+    customElements.define(VIOLATION_DETAIL_WIDGET, ViolationDetailWidget);
+    customElements.define(MAP_QUALITY_WIDGET, MapQualityWidget);
+    customElements.define(READING_PROPOSAL_WIDGET, ReadingProposalWidget);
 }

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

@@ -1,4 +1,4 @@
-import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '../../affine-model/index.js';
+import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel } from '../../affine-model/index.js';
 import { SurfaceElementModel } from './base.js';
 export declare const elementsCtorMap: {
     group: typeof GroupElementModel;
@@ -11,6 +11,7 @@ export declare const elementsCtorMap: {
     wardley: typeof WardleyBackgroundElementModel;
     wardleyNode: typeof WardleyNodeElementModel;
     edgy: typeof EdgyFacetsElementModel;
+    edgyBoard: typeof EdgyBoardElementModel;
     edgyNode: typeof EdgyNodeElementModel;
     cynefin: typeof CynefinElementModel;
     estuarine: typeof EstuarineElementModel;
@@ -18,7 +19,7 @@ export declare const elementsCtorMap: {
     bpmnNode: typeof BpmnNodeElementModel;
     bpmnPool: typeof BpmnPoolElementModel;
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
 export declare enum CanvasElementType {
     BRUSH = "brush",
     CONNECTOR = "connector",
@@ -30,6 +31,7 @@ export declare enum CanvasElementType {
     WARDLEY = "wardley",
     WARDLEYNODE = "wardleyNode",
     EDGY = "edgy",
+    EDGYBOARD = "edgyBoard",
     EDGYNODE = "edgyNode",
     CYNEFIN = "cynefin",
     ESTUARINE = "estuarine",
@@ -48,6 +50,7 @@ export type ElementModelMap = {
     ['wardley']: WardleyBackgroundElementModel;
     ['wardleyNode']: WardleyNodeElementModel;
     ['edgy']: EdgyFacetsElementModel;
+    ['edgyBoard']: EdgyBoardElementModel;
     ['edgyNode']: EdgyNodeElementModel;
     ['cynefin']: CynefinElementModel;
     ['estuarine']: EstuarineElementModel;

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

@@ -1,4 +1,4 @@
-import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '../../affine-model/index.js';
+import { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, } from '../../affine-model/index.js';
 import { SurfaceElementModel } from './base.js';
 export const elementsCtorMap = {
     group: GroupElementModel,
@@ -11,6 +11,7 @@ export const elementsCtorMap = {
     wardley: WardleyBackgroundElementModel,
     wardleyNode: WardleyNodeElementModel,
     edgy: EdgyFacetsElementModel,
+    edgyBoard: EdgyBoardElementModel,
     edgyNode: EdgyNodeElementModel,
     cynefin: CynefinElementModel,
     estuarine: EstuarineElementModel,
@@ -18,7 +19,7 @@ export const elementsCtorMap = {
     bpmnNode: BpmnNodeElementModel,
     bpmnPool: BpmnPoolElementModel,
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, ConnectorElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
 export var CanvasElementType;
 (function (CanvasElementType) {
     CanvasElementType["BRUSH"] = "brush";
@@ -31,6 +32,7 @@ export var CanvasElementType;
     CanvasElementType["WARDLEY"] = "wardley";
     CanvasElementType["WARDLEYNODE"] = "wardleyNode";
     CanvasElementType["EDGY"] = "edgy";
+    CanvasElementType["EDGYBOARD"] = "edgyBoard";
     CanvasElementType["EDGYNODE"] = "edgyNode";
     CanvasElementType["CYNEFIN"] = "cynefin";
     CanvasElementType["ESTUARINE"] = "estuarine";