@formicoidea/labre-core 0.33.0 → 0.34.2

package/dist/_pkgs/affine-block-surface/extensions/interchange-import.js

@@ -125,10 +125,21 @@ const REMARKS_IN_A_NOTIFICATION = 5;
  * rule is this simple one and not a title-casing.
  */
 const formatLabel = (format) => format.id.toUpperCase();
-/** One remark, as the line a reader sees. */
-function remarkLine(note) {
+/**
+ * One remark, as the line a reader sees.
+ *
+ * The reader that produced it had no `std` and could not translate it (P3), so
+ * this is where a remark that declared a key gets its wording — with its own
+ * `message` as the English default, exactly like every other `translateKey`
+ * call site. A remark with no key is one that names something out of the file
+ * and is shown as the reader wrote it (see `InterchangeNote.messageKey`).
+ */
+function remarkLine(std, note) {
+    const message = note.messageKey
+        ? translateKey(std, note.messageKey, note.message)
+        : note.message;
     const subject = note.sourceId ?? note.element;
-    return subject ? `${subject}: ${note.message}` : note.message;
+    return subject ? `${subject}: ${message}` : message;
 }
 /**
  * The notification seam, or silence.
@@ -214,7 +225,7 @@ export function reportInterchangeImport(std, format, report) {
     notifyImport(std, {
         title: translateKey(std, IMPORT_REMARKS_KEY, IMPORT_REMARKS_FALLBACK),
         message: notes.length <= REMARKS_IN_A_NOTIFICATION
-            ? notes.map(remarkLine).join('\n')
+            ? notes.map(note => remarkLine(std, note)).join('\n')
             : `${notes.length} ${translateKey(std, IMPORT_CONSOLE_KEY, IMPORT_CONSOLE_FALLBACK)}`,
         // Not `error`, and not `info`: nothing failed — every one of these is
         // something the document KEPT — but each one is a difference between the

package/dist/_pkgs/affine-block-surface/extensions/interchange.d.ts

@@ -95,6 +95,23 @@ export interface InterchangeNote {
     element?: string;
     /** One line, in the user's words: what happened and what it costs them. */
     message: string;
+    /**
+     * The i18n key {@link message} is the English default of — set only when the
+     * remark is a FIXED sentence.
+     *
+     * A reader is a pure function of text (`docs/adr/0012`, P3): it has no `std`,
+     * so it cannot reach the host's catalogue and hands the key over instead, and
+     * `reportInterchangeImport` resolves it when it draws the report. That is the
+     * whole of the seam here, and it deliberately covers only the remarks that
+     * say the same thing every time.
+     *
+     * A remark that NAMES something out of the file — an element, an id, a count
+     * of lanes — carries no key and stays English. The seam has no interpolation
+     * and no pluralisation (both are the host's), so the alternative would be to
+     * invent a grammar for sentences with holes in them, which is exactly what
+     * the three interchange count labels already refuse to do.
+     */
+    messageKey?: string;
 }
 /**
  * The five things worth saying about one item, and no sixth.

package/dist/_pkgs/affine-block-surface/extensions/spotlight.d.ts

@@ -1,4 +1,5 @@
 import type { ConnectorElementModel } from '../../affine-model/index.js';
+import type { Bound } from '../../global/gfx/index.js';
 import type { GfxModel } from '../../std/gfx/index.js';
 import { InteractivityExtension } from '../../std/gfx/index.js';
 import type { ExtensionType } from '../../store/index.js';
@@ -25,6 +26,26 @@ export declare function SpotlightHostExtension(elementType: string): ExtensionTy
  * two endpoints). Pure — exported for unit tests.
  */
 export declare function spotlightSet(target: GfxModel, getConnectors: (id: string) => ConnectorElementModel[]): Set<string>;
+/** The shape {@link findSpotlightHost} needs of a candidate host. */
+export type SpotlightHostCandidate = {
+    type: string;
+    elementBound: Bound;
+    spotlightEnabled?: boolean;
+};
+/**
+ * The host that grants `target` the spotlight, or `null` when none does.
+ *
+ * A host qualifies when its type was REGISTERED as a spotlight host
+ * (`SpotlightHostExtension`), when it did not opt out (`spotlightEnabled:
+ * false`, its toolbar toggle) and when its bounds contain the target. A
+ * background whose type is not registered grants nothing, whatever fields it
+ * carries — that is how the EDGY facets Venn stopped spotlighting (#195).
+ *
+ * Pure — exported for unit tests.
+ */
+export declare function findSpotlightHost<T extends SpotlightHostCandidate>(target: {
+    elementBound: Bound;
+}, elements: readonly T[], hostTypes: readonly string[]): T | null;
 export declare class SpotlightManager extends InteractivityExtension {
     static key: string;
     /** Elements currently faded, restored on leave. */

package/dist/_pkgs/affine-block-surface/extensions/spotlight.js

@@ -47,6 +47,22 @@ export function spotlightSet(target, getConnectors) {
     }
     return keep;
 }
+/**
+ * The host that grants `target` the spotlight, or `null` when none does.
+ *
+ * A host qualifies when its type was REGISTERED as a spotlight host
+ * (`SpotlightHostExtension`), when it did not opt out (`spotlightEnabled:
+ * false`, its toolbar toggle) and when its bounds contain the target. A
+ * background whose type is not registered grants nothing, whatever fields it
+ * carries — that is how the EDGY facets Venn stopped spotlighting (#195).
+ *
+ * Pure — exported for unit tests.
+ */
+export function findSpotlightHost(target, elements, hostTypes) {
+    return (elements.find(el => hostTypes.includes(el.type) &&
+        el.spotlightEnabled !== false &&
+        el.elementBound.contains(target.elementBound)) ?? null);
+}
 /** Delay before a new spotlight is applied / cleared, so brushing across
  * elements doesn't flash the fade on and off. */
 const SPOTLIGHT_DELAY_MS = 140;
@@ -120,9 +136,7 @@ export class SpotlightManager extends InteractivityExtension {
         // The behavior is granted by a host whose bounds contain the target —
         // unless that host opted out (`spotlightEnabled: false`, toolbar toggle).
         const host = target
-            ? surface.elementModels.find(el => hostTypes.includes(el.type) &&
-                el.spotlightEnabled !== false &&
-                el.elementBound.contains(target.elementBound))
+            ? findSpotlightHost(target, surface.elementModels, hostTypes)
             : null;
         if (!target || !host) {
             // Debounced restore: brushing across the gaps between elements must not

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

@@ -4,6 +4,7 @@ export { SurfaceElementModel, SurfaceGroupLikeModel, } from './element-model/bas
 export { CanvasElementType } from './element-model/index.js';
 export { CanvasRenderer } from './renderer/canvas-renderer.js';
 export { DomRenderer } from './renderer/dom-renderer.js';
+export { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 export type { ElementRenderer } from './renderer/elements/index.js';
 export * from './renderer/elements/type.js';
 export { Overlay, OverlayIdentifier } from './renderer/overlay.js';

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

@@ -6,6 +6,7 @@ export { SurfaceElementModel, SurfaceGroupLikeModel, } from './element-model/bas
 export { CanvasElementType } from './element-model/index.js';
 export { CanvasRenderer } from './renderer/canvas-renderer.js';
 export { DomRenderer } from './renderer/dom-renderer.js';
+export { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 export * from './renderer/elements/type.js';
 export { Overlay, OverlayIdentifier } from './renderer/overlay.js';
 export { ToolOverlay } from './renderer/tool-overlay.js';

package/dist/_pkgs/affine-block-surface/renderer/element-highlight-overlay.d.ts

@@ -0,0 +1,17 @@
+import type { GfxController } from '../../std/gfx/index.js';
+import { Overlay } from './overlay.js';
+/**
+ * Draws the transient emphasis ring around the elements held by
+ * `gfx.highlight` (`ElementHighlightManager`).
+ *
+ * The overlay is a pure renderer: it owns no state, reads nothing from the
+ * store and mutates nothing, which makes it safe on a read-only editor.
+ */
+export declare class ElementHighlightOverlay extends Overlay {
+    static overlayName: string;
+    private readonly _disposables;
+    private get _strokeColor();
+    constructor(gfx: GfxController);
+    dispose(): void;
+    render(ctx: CanvasRenderingContext2D): void;
+}

package/dist/_pkgs/affine-block-surface/renderer/element-highlight-overlay.js

@@ -0,0 +1,66 @@
+import { ThemeProvider } from '../../affine-shared/services/index.js';
+import { DisposableGroup } from '../../global/disposable/index.js';
+import { effect } from '@preact/signals-core';
+import { Overlay } from './overlay.js';
+/** Ring thickness, in screen pixels. */
+const HIGHLIGHT_STROKE_WIDTH = 2;
+/** Gap between the element bounds and the ring, in screen pixels. */
+const HIGHLIGHT_GAP = 4;
+/** Ring corner radius, in screen pixels. */
+const HIGHLIGHT_RADIUS = 4;
+/** Used when no theme is provided, matches the legacy frame highlight. */
+const FALLBACK_HIGHLIGHT_COLOR = '#1E96EB';
+/**
+ * Draws the transient emphasis ring around the elements held by
+ * `gfx.highlight` (`ElementHighlightManager`).
+ *
+ * The overlay is a pure renderer: it owns no state, reads nothing from the
+ * store and mutates nothing, which makes it safe on a read-only editor.
+ */
+export class ElementHighlightOverlay extends Overlay {
+    static { this.overlayName = 'element-highlight'; }
+    get _strokeColor() {
+        return (this.gfx.std
+            .getOptional(ThemeProvider)
+            ?.getCssVariableColor('--affine-primary-color') ??
+            FALLBACK_HIGHLIGHT_COLOR);
+    }
+    constructor(gfx) {
+        super(gfx);
+        this._disposables = new DisposableGroup();
+        this._disposables.add(effect(() => {
+            // Repaint the canvas whenever the highlighted set changes.
+            this.gfx.highlight.highlighted$.value;
+            this.refresh();
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    render(ctx) {
+        const elements = this.gfx.highlight.highlightedElements;
+        if (elements.length === 0)
+            return;
+        const { zoom } = this.gfx.viewport;
+        const gap = HIGHLIGHT_GAP / zoom;
+        const radius = HIGHLIGHT_RADIUS / zoom;
+        ctx.save();
+        ctx.strokeStyle = this._strokeColor;
+        ctx.lineWidth = HIGHLIGHT_STROKE_WIDTH / zoom;
+        for (const element of elements) {
+            const [x, y, w, h] = element.deserializedXYWH;
+            ctx.save();
+            // Rotate around the element center so rotated elements keep a tight
+            // ring; connectors and other non-rotatable elements use their bound box.
+            ctx.translate(x + w / 2, y + h / 2);
+            if (element.rotate) {
+                ctx.rotate((element.rotate * Math.PI) / 180);
+            }
+            ctx.beginPath();
+            ctx.roundRect(-w / 2 - gap, -h / 2 - gap, w + gap * 2, h + gap * 2, radius);
+            ctx.stroke();
+            ctx.restore();
+        }
+        ctx.restore();
+    }
+}

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

@@ -4,6 +4,7 @@ import { literal } from 'lit/static-html.js';
 import { effects } from './effects.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 { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 import { DefaultTool } from './tool/default-tool.js';
 export class SurfaceViewExtension extends ViewExtensionProvider {
     constructor() {
@@ -26,6 +27,10 @@ export class SurfaceViewExtension extends ViewExtensionProvider {
             context.register(DefaultTool);
             context.register(BlockViewExtension('affine:surface', literal `affine-surface`));
             context.register(EditPropsMiddlewareBuilder);
+            // Draws `gfx.highlightElements(...)`. Registered for `preview-edgeless`
+            // too — embedded read-only windows are the API's primary consumer — and
+            // paints nothing until a host asks for a highlight.
+            context.register(ElementHighlightOverlay);
             // No-op until a framework registers a SpotlightHostExtension.
             context.register(SpotlightManager);
             // No-op until a framework registers a ValidationRuleExtension — which

package/dist/_pkgs/affine-block-surface-ref/configs/toolbar.js

@@ -1,6 +1,6 @@
 import { toast } from '../../affine-components/toast/index.js';
 import { copySelectedModelsCommand, draftSelectedModelsCommand, } from '../../affine-shared/commands/index.js';
-import { ActionPlacement, blockCommentToolbarButton, } from '../../affine-shared/services/index.js';
+import { ActionPlacement, blockCommentToolbarButton, TOAST_COPIED_TO_CLIPBOARD, TOOLBAR_COPY, TOOLBAR_DELETE, translateKey, } from '../../affine-shared/services/index.js';
 import { CaptionIcon, CopyIcon, DeleteIcon } from '@blocksuite/icons/lit';
 import { html } from 'lit';
 import { SurfaceRefBlockComponent } from '../surface-ref-block.js';
@@ -20,7 +20,7 @@ export const surfaceRefToolbarModuleConfig = {
         },
         {
             id: 'c.copy-surface-ref',
-            label: 'Copy',
+            labelWording: TOOLBAR_COPY,
             icon: CopyIcon(),
             run: ctx => {
                 const surfaceRefBlock = ctx.getCurrentBlockByType(SurfaceRefBlockComponent);
@@ -32,7 +32,7 @@ export const surfaceRefToolbarModuleConfig = {
                 })
                     .pipe(copySelectedModelsCommand)
                     .run();
-                toast(surfaceRefBlock.std.host, 'Copied to clipboard');
+                toast(surfaceRefBlock.std.host, translateKey(surfaceRefBlock.std, ...TOAST_COPIED_TO_CLIPBOARD));
             },
         },
         {
@@ -64,7 +64,7 @@ export const surfaceRefToolbarModuleConfig = {
         },
         {
             id: 'g.surface-ref-deletion',
-            label: 'Delete',
+            labelWording: TOOLBAR_DELETE,
             icon: DeleteIcon(),
             placement: ActionPlacement.More,
             variant: 'destructive',

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();