@formicoidea/labre-core 0.31.0 → 0.32.0

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

@@ -1,8 +1,8 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
-import { BlockViewExtension, FlavourExtension } from '../std/index.js';
+import { BlockViewExtension, CommandExtension, FlavourExtension, } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { effects } from './effects.js';
-import { EdgelessCRUDExtension, EdgelessLegacySlotExtension, EditPropsMiddlewareBuilder, } from './extensions/index.js';
+import { auditCommands, EdgelessCRUDExtension, EdgelessLegacySlotExtension, EditPropsMiddlewareBuilder, mapQualityCommands, mapQualityWidget, ReadingManager, readingProposalWidget, readingToolbarExtension, SpotlightManager, ValidationManager, validationExceptionToolbarExtension, ValidationOverlay, violationDetailWidget, } from './extensions/index.js';
 import { ExportManagerExtension } from './extensions/export-manager/export-manager.js';
 import { DefaultTool } from './tool/default-tool.js';
 export class SurfaceViewExtension extends ViewExtensionProvider {
@@ -26,9 +26,64 @@ export class SurfaceViewExtension extends ViewExtensionProvider {
             context.register(DefaultTool);
             context.register(BlockViewExtension('affine:surface', literal `affine-surface`));
             context.register(EditPropsMiddlewareBuilder);
+            // No-op until a framework registers a SpotlightHostExtension.
+            context.register(SpotlightManager);
+            // No-op until a framework registers a ValidationRuleExtension — which
+            // only its FLAG-GATED view extension does, so a disabled framework
+            // costs no evaluation at all.
+            context.register(ValidationManager);
+            context.register(ValidationOverlay);
+            // The persistent badge and its detail bubble. Renders nothing until the
+            // manager reports a violation, which it cannot do without a rule.
+            context.register(violationDetailWidget);
+            // The reversed reading (MF3): the manager, the panel it opens and the
+            // toolbar entry that asks for it. All three are inert until a framework
+            // registers a ReadingProfile — which only its FLAG-GATED view extension
+            // does — and the panel opens on the `element.read` command and on
+            // nothing else: it never proposes itself, and it never writes.
+            context.register(ReadingManager);
+            context.register(readingProposalWidget);
+            context.register(readingToolbarExtension);
+            // "Revoke exception" on the contextual toolbar of whichever element
+            // answers for it. Shows nothing until an element carries an exception a
+            // REGISTERED rule can be arbitrated on, so a board with no framework
+            // enabled never sees it.
+            context.register(validationExceptionToolbarExtension);
+            // The Map quality panel (PF7.11) and the one command that opens it.
+            // Both are generic: they render and offer nothing until a framework
+            // registers a nudge or an on-demand rule, which only its FLAG-GATED view
+            // extension does.
+            context.register(mapQualityWidget);
+            context.register(CommandExtension(mapQualityCommands));
         }
         else {
             context.register(BlockViewExtension('affine:surface', literal `affine-surface-void`));
         }
     }
 }
+/**
+ * The AI audit seam — gated by the `ai-audit` capability switch (PF14.1).
+ *
+ * Its own extension, registered from `getInternalViewExtensions` only when the
+ * switch is on, because that is what makes the gate REAL: off, `map.audit` is
+ * never registered, so it is absent from the command registry, from both
+ * manifests and from the keymap at once — the same two-sided gating a framework
+ * flag gets, asserted by the same test.
+ *
+ * Nothing here is registered by {@link SurfaceViewExtension}: the audit is not
+ * part of a surface's job, and folding it in would make the switch a filter
+ * over something already wired instead of a decision not to wire it.
+ */
+export class AuditViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-audit-seam';
+    }
+    setup(context) {
+        super.setup(context);
+        // Edgeless only: an audit is about a map, and a map is a canvas artefact.
+        if (!this.isEdgeless(context.scope))
+            return;
+        context.register(CommandExtension(auditCommands));
+    }
+}

package/dist/_pkgs/affine-block-table/selection-controller.d.ts

@@ -6,6 +6,12 @@ export declare class SelectionController implements ReactiveController {
     readonly host: TableBlockComponent;
     constructor(host: TableBlockComponent);
     hostConnected(): void;
+    /**
+     * Claim a drag that starts on a resize/reorder handle. Without this the
+     * edgeless canvas turns the gesture into an element drag and the column
+     * never resizes.
+     */
+    private readonly onDragStartEvent;
     private get dataManager();
     private get clipboard();
     private get scale();

package/dist/_pkgs/affine-block-table/selection-controller.js

@@ -4,11 +4,26 @@ import { computed } from '@preact/signals-core';
 import { ColumnMinWidth, DefaultColumnWidth } from './consts.js';
 import { TableSelection, TableSelectionData, } from './selection-schema.js';
 import { createColumnDragPreview, createRowDragPreview, TableCellComponentName, } from './table-cell.js';
-import { cleanSelection } from './utils.js';
+import { cleanSelection, isTableDragHandle } from './utils.js';
 const TEXT = 'text/plain';
 export class SelectionController {
     constructor(host) {
         this.host = host;
+        /**
+         * Claim a drag that starts on a resize/reorder handle. Without this the
+         * edgeless canvas turns the gesture into an element drag and the column
+         * never resizes.
+         */
+        this.onDragStartEvent = (context) => {
+            if (IS_MOBILE || this.dataManager.readonly$.value)
+                return false;
+            const event = context.get('pointerState').raw;
+            if (!isTableDragHandle(event.target))
+                return false;
+            event.preventDefault();
+            event.stopPropagation();
+            return true;
+        };
         this.doCopyOrCut = (selection, isCut) => {
             const columns = this.dataManager.uiColumns$.value;
             const rows = this.dataManager.uiRows$.value;
@@ -164,6 +179,7 @@ export class SelectionController {
         this.host.handleEvent('copy', this.onCopy);
         this.host.handleEvent('cut', this.onCut);
         this.host.handleEvent('paste', this.onPaste);
+        this.host.handleEvent('dragStart', this.onDragStartEvent);
     }
     get dataManager() {
         return this.host.dataManager;
@@ -209,6 +225,13 @@ export class SelectionController {
         if (IS_MOBILE || this.dataManager.readonly$.value) {
             return;
         }
+        // Keep the pointer sequence inside the table too: in edgeless the canvas
+        // listens for `pointerdown` and would start dragging the block.
+        this.host.disposables.addFromEvent(this.host, 'pointerdown', event => {
+            if (isTableDragHandle(event.target)) {
+                event.stopPropagation();
+            }
+        });
         this.host.disposables.addFromEvent(this.host, 'mousedown', event => {
             const target = event.target;
             if (!(target instanceof HTMLElement)) {

package/dist/_pkgs/affine-block-table/table-block.js

@@ -100,9 +100,15 @@ export class TableBlockComponent extends CaptionedBlockComponent {
     }
     getScale() {
         const table = this.table$.value;
-        if (!table)
+        if (!table || !table.offsetWidth)
             return 1;
-        return table.getBoundingClientRect().width / table.offsetWidth;
+        const rectWidth = table.getBoundingClientRect().width;
+        // offsetWidth is rounded to an integer while the rect is fractional: on
+        // fractional devicePixelRatio a plain CSS width would read as a phantom
+        // ~1.0001 scale. Within rounding distance there is no transform.
+        if (Math.abs(rectWidth - table.offsetWidth) <= 0.5)
+            return 1;
+        return rectWidth / table.offsetWidth;
     }
     renderBlock() {
         const rows = this.dataManager.uiRows$.value;

package/dist/_pkgs/affine-block-table/table-cell.js

@@ -123,12 +123,11 @@ let TableCell = (() => {
             });
             this.richText$ = signal();
             this._handleKeyDown = (e) => {
-                if (e.key !== 'Escape') {
-                    if (e.key === 'Tab') {
-                        e.preventDefault();
-                        return;
-                    }
-                    e.stopPropagation();
+                // Tab is the only key the cell still swallows: it would move the focus out
+                // of the table. Everything else is left to propagate, so the table keymap
+                // (see table-keymap.ts) can answer it.
+                if (e.key === 'Tab') {
+                    e.preventDefault();
                 }
             };
         }

package/dist/_pkgs/affine-block-table/table-keymap.d.ts

@@ -0,0 +1,18 @@
+import { type BlockStdScope, type UIEventHandler } from '../std/index.js';
+/**
+ * Format hotkeys (bold, italic, …) for a table cell.
+ *
+ * The shared `textFormatKeymap` bails out unless the store holds a
+ * `TextSelection`, and a table cell never holds one: focusing a cell installs a
+ * `TableSelection` instead (see `selection-controller.ts`). The format commands
+ * themselves already fall back to the native selection, so that guard is the
+ * only thing standing between the user and a bold word. Dropping it here — for
+ * the table flavour alone — keeps every other block's behaviour untouched.
+ */
+export declare const tableTextFormatKeymap: (std: BlockStdScope) => Record<string, UIEventHandler>;
+/**
+ * Text shortcuts scoped to the table flavour. The cell no longer swallows every
+ * keystroke, so the shortcuts a user expects while typing reach this keymap —
+ * and stop there, instead of reaching the document.
+ */
+export declare const TableKeymapExtension: import("../store/index.js").ExtensionType;

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

@@ -0,0 +1,41 @@
+import { textFormatConfigs, textKeymap } from '../affine-inline-preset/index.js';
+import { TableBlockSchema } from '../affine-model/index.js';
+import { KeymapExtension, } from '../std/index.js';
+/**
+ * Format hotkeys (bold, italic, …) for a table cell.
+ *
+ * The shared `textFormatKeymap` bails out unless the store holds a
+ * `TextSelection`, and a table cell never holds one: focusing a cell installs a
+ * `TableSelection` instead (see `selection-controller.ts`). The format commands
+ * themselves already fall back to the native selection, so that guard is the
+ * only thing standing between the user and a bold word. Dropping it here — for
+ * the table flavour alone — keeps every other block's behaviour untouched.
+ */
+export const tableTextFormatKeymap = (std) => textFormatConfigs
+    .filter(config => config.hotkey)
+    .reduce((acc, config) => {
+    acc[config.hotkey] = ctx => {
+        if (std.store.readonly)
+            return;
+        const allowed = config.textChecker?.(std.host) ?? true;
+        if (!allowed)
+            return;
+        const event = ctx.get('keyboardState').raw;
+        event.stopPropagation();
+        event.preventDefault();
+        config.action(std.host);
+        return true;
+    };
+    return acc;
+}, {});
+/**
+ * Text shortcuts scoped to the table flavour. The cell no longer swallows every
+ * keystroke, so the shortcuts a user expects while typing reach this keymap —
+ * and stop there, instead of reaching the document.
+ */
+export const TableKeymapExtension = KeymapExtension(std => ({
+    ...textKeymap(std),
+    ...tableTextFormatKeymap(std),
+}), {
+    flavour: TableBlockSchema.model.flavour,
+});

package/dist/_pkgs/affine-block-table/utils.d.ts

@@ -1 +1,8 @@
+/**
+ * Whether an event started on one of those affordances. In edgeless the canvas
+ * claims `pointerdown`/`dragStart` before the table sees them, which turns a
+ * column resize into a canvas drag; the controller uses this to keep the
+ * gesture for itself.
+ */
+export declare const isTableDragHandle: (target: EventTarget | null) => boolean;
 export declare const cleanSelection: () => void;

package/dist/_pkgs/affine-block-table/utils.js

@@ -1,3 +1,15 @@
+/**
+ * The affordances a table drags with its own mouse listeners: the column
+ * width grip and the column/row drag handles.
+ */
+const TABLE_DRAG_HANDLE_SELECTOR = '[data-width-adjust-column-id], [data-drag-column-id], [data-drag-row-id]';
+/**
+ * Whether an event started on one of those affordances. In edgeless the canvas
+ * claims `pointerdown`/`dragStart` before the table sees them, which turns a
+ * column resize into a canvas drag; the controller uses this to keep the
+ * gesture for itself.
+ */
+export const isTableDragHandle = (target) => target instanceof Element && !!target.closest(TABLE_DRAG_HANDLE_SELECTOR);
 export const cleanSelection = () => {
     const selection = window.getSelection();
     if (selection) {

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

@@ -5,6 +5,7 @@ import { BlockViewExtension, FlavourExtension } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { tableSlashMenuConfig } from './configs/slash-menu.js';
 import { effects } from './effects.js';
+import { TableKeymapExtension } from './table-keymap.js';
 export class TableViewExtension extends ViewExtensionProvider {
     constructor() {
         super(...arguments);
@@ -18,6 +19,7 @@ export class TableViewExtension extends ViewExtensionProvider {
         super.setup(context);
         context.register([
             FlavourExtension(TableModelFlavour),
+            TableKeymapExtension,
             BlockViewExtension(TableModelFlavour, literal `affine-table`),
             SlashMenuConfigExtension(TableModelFlavour, tableSlashMenuConfig),
         ]);

package/dist/_pkgs/affine-components/caption/captioned-block-component.js

@@ -1,4 +1,5 @@
 import { ThemeProvider } from '../../affine-shared/services/index.js';
+import { watch } from '../../global/lit/index.js';
 import { BlockComponent } from '../../std/index.js';
 import { html, nothing } from 'lit';
 import { classMap } from 'lit/directives/class-map.js';
@@ -45,7 +46,7 @@ export class CaptionedBlockComponent extends BlockComponent {
             : nothing}
       ${this.selectedStyle === SelectedStyle.Background
             ? html `<affine-block-selection
-            .selected=${this.selected$.value}
+            .selected=${watch(this.selected$)}
           ></affine-block-selection>`
             : null}
       ${this.useZeroWidth && !this.store.readonly

package/dist/_pkgs/affine-components/context-menu/button.d.ts

@@ -9,6 +9,12 @@ export type MenuButtonData = {
     class: ClassInfo;
     select: (ele: HTMLElement) => void | false;
     onHover?: (hover: boolean) => void;
+    /**
+     * Keep the menu open after the item is selected. Defaults to `true`, which
+     * closes the menu — a toggle-like item passes `false` so the reader can flip
+     * several switches without reopening the menu each time.
+     */
+    closeOnSelect?: boolean;
     testId?: string;
 };
 export declare class MenuButton extends MenuFocusable {
@@ -39,6 +45,7 @@ export declare const menuButtonItems: {
         onHover?: (hover: boolean) => void;
         class?: MenuClass;
         hide?: () => boolean;
+        closeOnSelect?: boolean;
         testId?: string;
     }) => (menu: Menu) => TemplateResult<1> | undefined;
     checkbox: (config: {

package/dist/_pkgs/affine-components/context-menu/button.js

@@ -109,7 +109,9 @@ let MenuButton = (() => {
         onClick() {
             if (this.data.select(this) !== false) {
                 this.menu.options.onComplete?.();
-                this.menu.close();
+                if (this.data.closeOnSelect !== false) {
+                    this.menu.close();
+                }
             }
         }
         onPressEnter() {
@@ -186,7 +188,9 @@ let MobileMenuButton = (() => {
         onClick() {
             if (this.data.select(this) !== false) {
                 this.menu.options.onComplete?.();
-                this.menu.close();
+                if (this.data.closeOnSelect !== false) {
+                    this.menu.close();
+                }
             }
         }
         onPressEnter() {
@@ -244,6 +248,7 @@ export const menuButtonItems = {
             },
             onHover: config.onHover,
             select: config.select,
+            closeOnSelect: config.closeOnSelect,
             class: {
                 'selected-item': config.isSelected ?? false,
                 ...config.class,

package/dist/_pkgs/affine-components/context-menu/input.d.ts

@@ -8,11 +8,13 @@ export type MenuInputData = {
     class?: string;
     onComplete?: (value: string) => void;
     onChange?: (value: string) => void;
+    onBlur?: (value: string) => void;
     disableAutoFocus?: boolean;
 };
 export declare class MenuInput extends MenuFocusable {
     static styles: import("lit").CSSResult;
     private readonly onCompositionEnd;
+    private readonly onBlur;
     private readonly onInput;
     private readonly onKeydown;
     private readonly stopPropagation;
@@ -26,6 +28,7 @@ export declare class MenuInput extends MenuFocusable {
 export declare class MobileMenuInput extends MenuFocusable {
     static styles: import("lit").CSSResult;
     private readonly onCompositionEnd;
+    private readonly onBlur;
     private readonly onInput;
     private readonly stopPropagation;
     complete(): void;
@@ -42,6 +45,7 @@ export declare const menuInputItems: {
         prefix?: TemplateResult;
         onComplete?: (value: string) => void;
         onChange?: (value: string) => void;
+        onBlur?: (value: string) => void;
         class?: string;
         style?: Readonly<StyleInfo>;
     }) => (menu: Menu) => TemplateResult<1> | undefined;

package/dist/_pkgs/affine-components/context-menu/input.js

@@ -110,6 +110,7 @@ let MenuInput = (() => {
       @focus="${() => {
                 this.menu.setFocusOnly(this);
             }}"
+      @blur="${this.onBlur}"
       @input="${this.onInput}"
       placeholder="${this.data.placeholder ?? ''}"
       @keypress="${this.stopPropagation}"
@@ -133,6 +134,9 @@ let MenuInput = (() => {
             this.onCompositionEnd = () => {
                 this.data.onChange?.(this.inputRef.value);
             };
+            this.onBlur = () => {
+                this.data.onBlur?.(this.inputRef.value);
+            };
             this.onInput = (e) => {
                 e.stopPropagation();
                 if (e.isComposing)
@@ -151,6 +155,9 @@ let MenuInput = (() => {
                 }
                 if (e.key === 'Enter') {
                     this.complete();
+                    // Blur before the menu goes away: unmounting a focused input does not
+                    // emit `blur`, and blur is where the value is saved.
+                    this.inputRef.blur();
                     this.menu.close();
                     return;
                 }
@@ -209,6 +216,7 @@ let MobileMenuInput = (() => {
       @focus="${() => {
                 this.menu.setFocusOnly(this);
             }}"
+      @blur="${this.onBlur}"
       @input="${this.onInput}"
       @copy="${this.stopPropagation}"
       @paste="${this.stopPropagation}"
@@ -229,6 +237,9 @@ let MobileMenuInput = (() => {
             this.onCompositionEnd = () => {
                 this.data.onChange?.(this.inputRef.value);
             };
+            this.onBlur = () => {
+                this.data.onBlur?.(this.inputRef.value);
+            };
             this.onInput = (e) => {
                 e.stopPropagation();
                 if (e.isComposing)
@@ -270,6 +281,7 @@ export const menuInputItems = {
             class: config.class,
             onComplete: config.onComplete,
             onChange: config.onChange,
+            onBlur: config.onBlur,
         };
         const style = styleMap({
             display: 'flex',

package/dist/_pkgs/affine-components/context-menu/menu-all.d.ts

@@ -11,6 +11,7 @@ export declare const menu: {
         prefix?: import("lit-html").TemplateResult;
         onComplete?: (value: string) => void;
         onChange?: (value: string) => void;
+        onBlur?: (value: string) => void;
         class?: string;
         style?: Readonly<import("lit-html/directives/style-map.js").StyleInfo>;
     }) => (menu: import("./menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
@@ -36,6 +37,7 @@ export declare const menu: {
         onHover?: (hover: boolean) => void;
         class?: import("./types.js").MenuClass;
         hide?: () => boolean;
+        closeOnSelect?: boolean;
         testId?: string;
     }) => (menu: import("./menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
     checkbox: (config: {

package/dist/_pkgs/affine-components/context-menu/menu-renderer.js

@@ -444,11 +444,14 @@ export const popupTargetFromElement = (element) => {
 };
 export const createPopup = (target, content, options) => {
     const close = () => {
+        // Removing the modal does not stop the positioning loop: without this the
+        // `autoUpdate` listeners outlive the popup and leak.
+        cleanup();
         modal.remove();
         options?.onClose?.();
     };
     const modal = createModal(target.root);
-    autoUpdate(target.targetRect, content, () => {
+    const cleanup = autoUpdate(target.targetRect, content, () => {
         computePosition(target.targetRect, content, {
             middleware: options?.middleware ?? [shift({ crossAxis: true })],
         })
@@ -532,6 +535,10 @@ export const popMenu = (target, props) => {
                 ],
             }),
             offset(4),
+            // Keep the menu inside the viewport: on a constrained viewport the
+            // allowed placements can all overflow, and without a shift the menu
+            // simply hangs off the edge of the screen.
+            shift({ padding: 8 }),
         ],
         container: props.container,
     });

package/dist/_pkgs/affine-components/context-menu/sub-menu.js

@@ -111,6 +111,9 @@ let MenuSubMenu = (() => {
                     .catch(err => console.error(err));
             });
             this.menu.openSubMenu(menu);
+            // The sub-menu can still be open when this component is removed: without
+            // this the `autoUpdate` listeners outlive the element and leak.
+            this.disposables.add(unsub);
         }
         render() {
             const classString = classMap({

package/dist/_pkgs/affine-components/highlight-dropdown-menu/highlight-duotone-icon.js

@@ -1,14 +1,14 @@
 import { HighLightDuotoneIcon } from '@blocksuite/icons/lit';
 import { css, LitElement } from 'lit';
 export class HighlightDuotoneIcon extends LitElement {
-    static { this.styles = css `
-    svg {
-      display: flex;
-      font-size: 20px;
-    }
-    svg > path:nth-child(1) {
-      fill: var(--color, unset);
-    }
+    static { this.styles = css `
+    svg {
+      display: flex;
+      font-size: 20px;
+    }
+    svg > path:nth-child(1) {
+      fill: var(--color, unset);
+    }
   `; }
     render() {
         return HighLightDuotoneIcon();

package/dist/_pkgs/affine-components/highlight-dropdown-menu/text-duotone-icon.js

@@ -1,17 +1,17 @@
 import { TextBackgroundDuotoneIcon } from '@blocksuite/icons/lit';
 import { css, LitElement } from 'lit';
 export class TextDuotoneIcon extends LitElement {
-    static { this.styles = css `
-    svg {
-      display: flex;
-      font-size: 20px;
-    }
-    svg > path:nth-child(1) {
-      fill: var(--background, unset);
-    }
-    svg > path:nth-child(3) {
-      fill: var(--color, unset);
-    }
+    static { this.styles = css `
+    svg {
+      display: flex;
+      font-size: 20px;
+    }
+    svg > path:nth-child(1) {
+      fill: var(--background, unset);
+    }
+    svg > path:nth-child(3) {
+      fill: var(--color, unset);
+    }
   `; }
     render() {
         return TextBackgroundDuotoneIcon();

package/dist/_pkgs/affine-components/icon-picker/affine-icon-picker-panel.d.ts

@@ -0,0 +1,28 @@
+import { LitElement } from 'lit';
+import { type PickerIcon } from './icon-data.js';
+/**
+ * The icon half of the picker: a filter box, a colour menu, a recents row and
+ * the full `@blocksuite/icons` set.
+ */
+export declare class AffineIconPickerPanel extends LitElement {
+    static styles: import("lit").CSSResult[];
+    private accessor _keyword;
+    private accessor _colorMenuOpen;
+    private accessor _recent;
+    /**
+     * The tint applied to a picked icon. Exposed so a host can open the picker
+     * on the colour the block already wears.
+     */
+    accessor color: string;
+    accessor rememberRecent: boolean;
+    get icons(): PickerIcon[];
+    firstUpdated(): void;
+    private readonly _select;
+    private _renderGroup;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'affine-icon-picker-panel': AffineIconPickerPanel;
+    }
+}