@formicoidea/labre-core 0.40.0 → 0.42.0

package/dist/_pkgs/affine-widget-edgeless-toolbar/menu/senior-menu-selection.d.ts

@@ -0,0 +1,15 @@
+import { type AnyCommandDescriptor, type BlockStdScope, type CommandOwner } from '../../std/index.js';
+/**
+ * The row one framework's senior sub-menu shows, and whether the owner outgrew
+ * its slots — `selectSeniorMenuCommands` fed from the registry and the user's
+ * own usage measure.
+ *
+ * It lives beside the menu rather than inside it because the ROW is now read by
+ * two things: the popover that draws it, and the placement tool that cycles
+ * along it on Shift+S. One reading, so the ghost can never step onto a button
+ * the menu does not show.
+ */
+export declare function seniorMenuSelection(std: BlockStdScope, owner: CommandOwner): {
+    commands: AnyCommandDescriptor[];
+    overflow: boolean;
+};

package/dist/_pkgs/affine-widget-edgeless-toolbar/menu/senior-menu-selection.js

@@ -0,0 +1,15 @@
+import { CommandUsageIdentifier, getCommandsForSurface, selectSeniorMenuCommands, } from '../../std/index.js';
+/**
+ * The row one framework's senior sub-menu shows, and whether the owner outgrew
+ * its slots — `selectSeniorMenuCommands` fed from the registry and the user's
+ * own usage measure.
+ *
+ * It lives beside the menu rather than inside it because the ROW is now read by
+ * two things: the popover that draws it, and the placement tool that cycles
+ * along it on Shift+S. One reading, so the ghost can never step onto a button
+ * the menu does not show.
+ */
+export function seniorMenuSelection(std, owner) {
+    const usage = std.getOptional(CommandUsageIdentifier);
+    return selectSeniorMenuCommands(getCommandsForSurface(std, owner, 'senior-menu'), getCommandsForSurface(std, owner, 'catalogue'), id => usage?.statsOf(id));
+}

package/dist/_pkgs/affine-widget-edgeless-toolbar/panel/font-weight-and-style-panel.d.ts

@@ -1,13 +1,21 @@
 import { FontFamily, FontStyle, FontWeight } from '../../affine-model/index.js';
+import type { BlockStdScope } from '../../std/index.js';
 import { LitElement } from 'lit';
 export declare class EdgelessFontWeightAndStylePanel extends LitElement {
     static styles: import("lit").CSSResult;
     private _isActive;
     private _isDisabled;
     private _onSelect;
+    /** The wording for a font weight — translated when `std` is available. */
+    private _weightLabel;
+    private get _italicLabel();
     render(): Iterable<unknown>;
     accessor fontFamily: FontFamily;
     accessor fontStyle: FontStyle;
     accessor fontWeight: FontWeight;
     accessor onSelect: ((fontWeight: FontWeight, fontStyle: FontStyle) => void) | undefined;
+    /** Set by the caller that has one (`gfx/text`'s `createTextActions`) —
+     * optional so this panel still renders (in English) when created with
+     * none. */
+    accessor std: BlockStdScope | undefined;
 }

package/dist/_pkgs/affine-widget-edgeless-toolbar/panel/font-weight-and-style-panel.js

@@ -34,16 +34,23 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { TextUtils } from '../../affine-block-surface/index.js';
 import { FontFamily, FontFamilyMap, FontStyle, FontWeight, } from '../../affine-model/index.js';
+import { FONT_STYLE_ITALIC, FONT_WEIGHT_BOLD, FONT_WEIGHT_LIGHT, FONT_WEIGHT_REGULAR, FONT_WEIGHT_SEMIBOLD, translateKey, } from '../../affine-shared/services/index.js';
 import { DoneIcon } from '@blocksuite/icons/lit';
 import { css, html, LitElement, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
-import { choose } from 'lit/directives/choose.js';
 import { join } from 'lit/directives/join.js';
 import { repeat } from 'lit/directives/repeat.js';
+/**
+ * How each weight is named. The panel does not offer this list: it offers the
+ * faces the current family actually has loaded, and only borrows the wording
+ * from here — so a family that ships no 700 file simply never draws a Bold
+ * row.
+ */
 const FONT_WEIGHT_CHOOSE = [
-    [FontWeight.Light, () => 'Light'],
-    [FontWeight.Regular, () => 'Regular'],
-    [FontWeight.SemiBold, () => 'Semibold'],
+    [FontWeight.Light, FONT_WEIGHT_LIGHT],
+    [FontWeight.Regular, FONT_WEIGHT_REGULAR],
+    [FontWeight.SemiBold, FONT_WEIGHT_SEMIBOLD],
+    [FontWeight.Bold, FONT_WEIGHT_BOLD],
 ];
 let EdgelessFontWeightAndStylePanel = (() => {
     let _classSuper = LitElement;
@@ -59,6 +66,9 @@ let EdgelessFontWeightAndStylePanel = (() => {
     let _onSelect_decorators;
     let _onSelect_initializers = [];
     let _onSelect_extraInitializers = [];
+    let _std_decorators;
+    let _std_initializers = [];
+    let _std_extraInitializers = [];
     return class EdgelessFontWeightAndStylePanel extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -66,10 +76,12 @@ let EdgelessFontWeightAndStylePanel = (() => {
             _fontStyle_decorators = [property({ attribute: false })];
             _fontWeight_decorators = [property({ attribute: false })];
             _onSelect_decorators = [property({ attribute: false })];
+            _std_decorators = [property({ attribute: false })];
             __esDecorate(this, null, _fontFamily_decorators, { kind: "accessor", name: "fontFamily", static: false, private: false, access: { has: obj => "fontFamily" in obj, get: obj => obj.fontFamily, set: (obj, value) => { obj.fontFamily = value; } }, metadata: _metadata }, _fontFamily_initializers, _fontFamily_extraInitializers);
             __esDecorate(this, null, _fontStyle_decorators, { kind: "accessor", name: "fontStyle", static: false, private: false, access: { has: obj => "fontStyle" in obj, get: obj => obj.fontStyle, set: (obj, value) => { obj.fontStyle = value; } }, metadata: _metadata }, _fontStyle_initializers, _fontStyle_extraInitializers);
             __esDecorate(this, null, _fontWeight_decorators, { kind: "accessor", name: "fontWeight", static: false, private: false, access: { has: obj => "fontWeight" in obj, get: obj => obj.fontWeight, set: (obj, value) => { obj.fontWeight = value; } }, metadata: _metadata }, _fontWeight_initializers, _fontWeight_extraInitializers);
             __esDecorate(this, null, _onSelect_decorators, { kind: "accessor", name: "onSelect", static: false, private: false, access: { has: obj => "onSelect" in obj, get: obj => obj.onSelect, set: (obj, value) => { obj.onSelect = value; } }, metadata: _metadata }, _onSelect_initializers, _onSelect_extraInitializers);
+            __esDecorate(this, null, _std_decorators, { kind: "accessor", name: "std", static: false, private: false, access: { has: obj => "std" in obj, get: obj => obj.std, set: (obj, value) => { obj.std = value; } }, metadata: _metadata }, _std_initializers, _std_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = css `
@@ -103,6 +115,18 @@ let EdgelessFontWeightAndStylePanel = (() => {
                 this.onSelect(fontWeight, fontStyle);
             }
         }
+        /** The wording for a font weight — translated when `std` is available. */
+        _weightLabel(weight) {
+            const wording = FONT_WEIGHT_CHOOSE.find(([w]) => w === weight)?.[1];
+            if (!wording)
+                return '';
+            return this.std ? translateKey(this.std, ...wording) : wording[1];
+        }
+        get _italicLabel() {
+            return this.std
+                ? translateKey(this.std, ...FONT_STYLE_ITALIC)
+                : FONT_STYLE_ITALIC[1];
+        }
         render() {
             let fontFaces = TextUtils.getFontFacesByFontFamily(this.fontFamily);
             // Compatible with old data
@@ -125,7 +149,7 @@ let EdgelessFontWeightAndStylePanel = (() => {
                     .iconSize=${'20px'}
                     @click=${() => this._onSelect(fontFace.weight)}
                   >
-                    ${choose(fontFace.weight, FONT_WEIGHT_CHOOSE)}
+                    ${this._weightLabel(fontFace.weight)}
                     ${active ? DoneIcon() : nothing}
                   </edgeless-tool-icon-button>
                 `;
@@ -143,8 +167,8 @@ let EdgelessFontWeightAndStylePanel = (() => {
                     .active=${active}
                     @click=${() => this._onSelect(fontFace.weight, FontStyle.Italic)}
                   >
-                    ${choose(fontFace.weight, FONT_WEIGHT_CHOOSE)} Italic
-                    ${active ? DoneIcon() : nothing}
+                    ${this._weightLabel(fontFace.weight)}
+                    ${this._italicLabel} ${active ? DoneIcon() : nothing}
                   </edgeless-tool-icon-button>
                 `;
                     })
@@ -167,9 +191,15 @@ let EdgelessFontWeightAndStylePanel = (() => {
         #onSelect_accessor_storage = (__runInitializers(this, _fontWeight_extraInitializers), __runInitializers(this, _onSelect_initializers, void 0));
         get onSelect() { return this.#onSelect_accessor_storage; }
         set onSelect(value) { this.#onSelect_accessor_storage = value; }
+        #std_accessor_storage = (__runInitializers(this, _onSelect_extraInitializers), __runInitializers(this, _std_initializers, undefined));
+        /** Set by the caller that has one (`gfx/text`'s `createTextActions`) —
+         * optional so this panel still renders (in English) when created with
+         * none. */
+        get std() { return this.#std_accessor_storage; }
+        set std(value) { this.#std_accessor_storage = value; }
         constructor() {
             super(...arguments);
-            __runInitializers(this, _onSelect_extraInitializers);
+            __runInitializers(this, _std_extraInitializers);
         }
     };
 })();

package/dist/_pkgs/affine-widget-edgeless-toolbar/placement/artefact-ghost-overlay.d.ts

@@ -0,0 +1,42 @@
+import { type RoughCanvas, ToolOverlay } from '../../affine-block-surface/index.js';
+import type { Bound } from '../../global/gfx/index.js';
+import type { GfxController, GfxPrimitiveElementModel } from '../../std/gfx/index.js';
+/**
+ * The ghost an armed {@link ArtefactPlacementTool} leaves under the cursor: the
+ * artefact itself, painted by the very renderers that will paint it once it is
+ * placed, at full opacity (PO decision, 2026-09-16).
+ *
+ * The elements are DETACHED models (`createDetachedElement`), built once by the
+ * tool from the recording of the command — never per frame, and never in the
+ * document. Each frame only runs the renderers, in paint order.
+ *
+ * When nothing could be built — the recording threw, or recorded nothing the
+ * surface can build — the ghost falls back to what the tool can still promise:
+ * a dashed footprint and the command's label under it. A real preview carries
+ * its own words, so it gets no label.
+ *
+ * Like `ShapeOverlay`, everything is positioned from {@link ToolOverlay.x} /
+ * {@link ToolOverlay.y} — the cursor in model coordinates — and the recorded
+ * boxes are offsets around it, because the recording ran against a viewport
+ * whose centre was the origin. The same offset is what the placement re-applies
+ * for real.
+ */
+export declare class ArtefactGhostOverlay extends ToolOverlay {
+    /** The footprint, relative to the cursor. */
+    bound: Bound;
+    /** What the command is called, in the reader's language. */
+    label: string;
+    /** The artefact's drawable elements, in paint order, with their renderer. */
+    private readonly _preview;
+    constructor(gfx: GfxController, bound: Bound, label: string, models?: GfxPrimitiveElementModel[]);
+    /** Whether the artefact itself is drawn, rather than the fallback box. */
+    get drawsArtefact(): boolean;
+    render(ctx: CanvasRenderingContext2D, rc: RoughCanvas): void;
+    /**
+     * What the surface's render loop does per element, with the cursor in place
+     * of the element's position: the context is already in model coordinates
+     * here, so the element's matrix is that transform moved to cursor + offset.
+     */
+    private _renderArtefact;
+    private _renderFootprint;
+}

package/dist/_pkgs/affine-widget-edgeless-toolbar/placement/artefact-ghost-overlay.js

@@ -0,0 +1,100 @@
+import { CanvasRenderer, ElementRendererIdentifier, ToolOverlay, } from '../../affine-block-surface/index.js';
+import { ThemeProvider } from '../../affine-shared/services/index.js';
+/** Gap between the bottom of the footprint and the baseline of the label. */
+const LABEL_GAP = 16;
+/** Label size in SCREEN pixels; divided by the zoom before it is drawn. */
+const LABEL_SIZE = 12;
+/**
+ * The ghost an armed {@link ArtefactPlacementTool} leaves under the cursor: the
+ * artefact itself, painted by the very renderers that will paint it once it is
+ * placed, at full opacity (PO decision, 2026-09-16).
+ *
+ * The elements are DETACHED models (`createDetachedElement`), built once by the
+ * tool from the recording of the command — never per frame, and never in the
+ * document. Each frame only runs the renderers, in paint order.
+ *
+ * When nothing could be built — the recording threw, or recorded nothing the
+ * surface can build — the ghost falls back to what the tool can still promise:
+ * a dashed footprint and the command's label under it. A real preview carries
+ * its own words, so it gets no label.
+ *
+ * Like `ShapeOverlay`, everything is positioned from {@link ToolOverlay.x} /
+ * {@link ToolOverlay.y} — the cursor in model coordinates — and the recorded
+ * boxes are offsets around it, because the recording ran against a viewport
+ * whose centre was the origin. The same offset is what the placement re-applies
+ * for real.
+ */
+export class ArtefactGhostOverlay extends ToolOverlay {
+    constructor(gfx, bound, label, models = []) {
+        super(gfx);
+        this.bound = bound;
+        this.label = label;
+        // Resolved once: a type without a canvas renderer is skipped silently, as
+        // the surface's own render loop skips it.
+        this._preview = models.flatMap(model => {
+            const render = gfx.std.getOptional(ElementRendererIdentifier(model.type));
+            return render ? [{ model, render }] : [];
+        });
+    }
+    /** Whether the artefact itself is drawn, rather than the fallback box. */
+    get drawsArtefact() {
+        return this._preview.length > 0;
+    }
+    render(ctx, rc) {
+        ctx.globalAlpha = this.globalAlpha;
+        if (this.globalAlpha === 0)
+            return;
+        const renderer = this.gfx.surfaceComponent
+            ?.renderer;
+        if (this.drawsArtefact && renderer instanceof CanvasRenderer) {
+            this._renderArtefact(ctx, rc, renderer);
+        }
+        else {
+            this._renderFootprint(ctx);
+        }
+    }
+    /**
+     * What the surface's render loop does per element, with the cursor in place
+     * of the element's position: the context is already in model coordinates
+     * here, so the element's matrix is that transform moved to cursor + offset.
+     */
+    _renderArtefact(ctx, rc, renderer) {
+        const base = ctx.getTransform();
+        const viewportBound = this.gfx.viewport.viewportBounds;
+        for (const { model, render } of this._preview) {
+            const [x, y] = model.deserializedXYWH;
+            ctx.save();
+            ctx.globalAlpha = model.opacity ?? 1;
+            render(model, ctx, base.translate(this.x + x, this.y + y), renderer, rc, viewportBound);
+            ctx.restore();
+        }
+    }
+    _renderFootprint(ctx) {
+        const theme = this.gfx.std.get(ThemeProvider);
+        const stroke = theme.getCssVariableColor('--affine-primary-color');
+        const text = theme.getCssVariableColor('--affine-text-secondary-color');
+        // Chrome, not content: the outline and the label keep their size on screen
+        // whatever the zoom, the way the polygon tool's own indicators do.
+        const zoom = this.gfx.viewport.zoom;
+        const { bound } = this;
+        const x = this.x + bound.x;
+        const y = this.y + bound.y;
+        const radius = Math.min(8 / zoom, bound.w / 4, bound.h / 4);
+        ctx.save();
+        ctx.beginPath();
+        ctx.roundRect(x, y, bound.w, bound.h, radius);
+        ctx.strokeStyle = stroke;
+        ctx.lineWidth = 1.5 / zoom;
+        ctx.setLineDash([6 / zoom, 4 / zoom]);
+        ctx.stroke();
+        if (this.label) {
+            ctx.setLineDash([]);
+            ctx.font = `${LABEL_SIZE / zoom}px var(--affine-font-family, sans-serif)`;
+            ctx.fillStyle = text;
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'top';
+            ctx.fillText(this.label, x + bound.w / 2, y + bound.h + LABEL_GAP / zoom - LABEL_SIZE / zoom);
+        }
+        ctx.restore();
+    }
+}

package/dist/_pkgs/affine-widget-edgeless-toolbar/placement/artefact-placement-tool.d.ts

@@ -0,0 +1,100 @@
+import { type AnyCommandDescriptor, type BlockStdScope, type CommandOwner, type PointerEventState } from '../../std/index.js';
+import { BaseTool, type GfxController } from '../../std/gfx/index.js';
+export type ArtefactPlacementOption = {
+    /** Whose senior menu armed this, and therefore whose row Shift+S walks. */
+    owner: CommandOwner;
+    command: AnyCommandDescriptor;
+};
+/**
+ * ONE tool for every framework's artefacts: pick one from a senior menu and it
+ * is not created, it is ARMED — a ghost follows the cursor and the click says
+ * where (PO decision, 2026-09-16).
+ *
+ * The shape tool has always worked this way, and a framework artefact is a
+ * shape the framework named. Before this, an artefact landed at the viewport
+ * centre whatever the author was looking at, and putting it where they meant it
+ * to go was a second gesture with a mouse held down.
+ *
+ * It is generic on purpose. Nothing here knows what a Wardley component or a
+ * BPMN gateway is: the armed {@link CommandDescriptor} carries its own label,
+ * its own creation body and its own telemetry, and the footprint is MEASURED by
+ * running that body against the recording fake (`recordAction`) rather than
+ * declared a second time. A ninth framework arms this tool by existing.
+ *
+ * What it deliberately does not do:
+ *
+ * - **Telemetry.** Arming and cycling emit nothing and record no usage, exactly
+ *   as choosing a shape variant does. The one emission still happens where it
+ *   always did — inside {@link runCommand}, at placement — so the numbers a
+ *   framework already reports are unchanged, and a user who arms an artefact
+ *   and changes their mind has not "used" it.
+ * - **Drag to size.** A framework artefact has a size its framework chose; the
+ *   click places that size. Out of scope, deliberately.
+ */
+export declare class ArtefactPlacementTool extends BaseTool<ArtefactPlacementOption> {
+    static toolName: string;
+    private _ghost;
+    private get _surfaceComponent();
+    activate(): void;
+    deactivate(): void;
+    clearOverlay(): void;
+    /**
+     * Record the armed command once, and hang its ghost off the cursor.
+     *
+     * Once per arming and per cycle, never per pointer move: the recording runs
+     * the command's whole creation body against a fake and the preview builds a
+     * model per element, which is cheap but not free — and neither can change
+     * between two mouse positions.
+     *
+     * An artefact made of connectors only gets no ghost at all: a connector is
+     * not previewed (PO decision, 2026-09-16), and the crosshair alone says the
+     * next click places something.
+     */
+    createOverlay(): void;
+    /**
+     * Place the artefact under the cursor.
+     *
+     * The command is not asked WHERE to create — every one of them creates around
+     * the viewport centre, and teaching eight frameworks' worth of actions to take
+     * a point would be the per-framework code this tool exists to avoid. So the
+     * command runs as it always has, and what it created is moved by the offset
+     * between the centre it aimed at and the point the user clicked. That offset
+     * is read BEFORE the run, because a command may move the viewport.
+     */
+    click(e: PointerEventState): void;
+    pointerMove(e: PointerEventState): void;
+    pointerOut(e: PointerEventState): void;
+    /** A framework artefact keeps the size its framework chose; a drag is a click. */
+    dragStart(_e: PointerEventState): void;
+    dragMove(_e: PointerEventState): void;
+    dragEnd(_e: PointerEventState): void;
+}
+/** The armed artefact, or `null` when the editor is on any other tool. */
+export declare function armedArtefact(gfx: GfxController): ArtefactPlacementOption | null;
+/** Arm `command`; the ghost appears with the next pointer move. */
+export declare function armArtefact(gfx: GfxController, owner: CommandOwner, command: AnyCommandDescriptor): void;
+/**
+ * The artefacts of one owner, in the order its senior menu shows them.
+ *
+ * The MENU's row and not the whole catalogue: cycling is a keyboard walk along
+ * a row of buttons the user is looking at, and a Shift+S that stepped onto an
+ * artefact filed away in the sidepanel would move the ghost with nothing on
+ * screen to explain it. An owner past the fourteen-slot cap therefore cycles
+ * through its thirteen ranked artefacts; the rest stay one catalogue away.
+ *
+ * `kind` is what decides, not the owner: an entry of kind `'tool'` — a link
+ * tool, the evolution arrow, the Wardley area polygon — arms a gesture of its
+ * own and has no footprint to ghost, so it is never armed here and never
+ * stepped onto.
+ */
+export declare function artefactCommandsFor(std: BlockStdScope, owner: CommandOwner): AnyCommandDescriptor[];
+/**
+ * Arm the artefact `dir` steps along the owner's row, wrapping at both ends.
+ * Returns false when nothing is armed, so a caller can fall through to whatever
+ * the keystroke means otherwise.
+ *
+ * An artefact armed from the catalogue is not in the row: a backwards step then
+ * enters on the row's last entry, a forwards one on its first — the same "enter
+ * from nothing" the open menu's highlight gives.
+ */
+export declare function cycleArmedArtefact(gfx: GfxController, dir: 1 | -1): boolean;