@formicoidea/labre-core 0.41.0 → 0.42.0

package/dist/_pkgs/affine-gfx-shape/overlay/polygon-drawing-overlay.js

@@ -59,10 +59,39 @@ export class PolygonDrawingOverlay extends ToolOverlay {
     _effectiveStrokeColor() {
         return this._strokeStyle === 'none' ? 'transparent' : this._strokeColor;
     }
+    /**
+     * The marker shown at the pointer while the tool is armed and empty: the same
+     * dot the first placed vertex gets, plus a light ring, so the promise the
+     * cursor makes is the shape the click keeps.
+     */
+    _renderFirstVertexHint(ctx, [cx, cy]) {
+        const zoom = this.gfx.viewport.zoom;
+        ctx.beginPath();
+        ctx.arc(cx, cy, VERTEX_INDICATOR_RADIUS, 0, Math.PI * 2);
+        ctx.fillStyle = this._strokeColor;
+        ctx.fill();
+        ctx.beginPath();
+        ctx.arc(cx, cy, CLOSE_SNAP_INDICATOR_RADIUS / zoom, 0, Math.PI * 2);
+        ctx.strokeStyle = this._strokeColor;
+        ctx.lineWidth = 1.5 / zoom;
+        ctx.setLineDash([]);
+        ctx.globalAlpha = this.globalAlpha * 0.4;
+        ctx.stroke();
+        ctx.globalAlpha = this.globalAlpha;
+    }
     render(ctx, _rc) {
         const { vertices, cursorPos, isDrawing } = this;
         ctx.globalAlpha = this.globalAlpha;
-        if (!isDrawing || vertices.length === 0)
+        if (vertices.length === 0) {
+            // Nothing is placed yet, so there is no outline to preview — but the tool
+            // IS armed, and until now the canvas said nothing about it. Marking where
+            // the next click would land a corner is what tells the author the board
+            // is waiting for a first vertex rather than ignoring the pointer.
+            if (cursorPos)
+                this._renderFirstVertexHint(ctx, cursorPos);
+            return;
+        }
+        if (!isDrawing)
             return;
         const effectiveStroke = this._effectiveStrokeColor();
         const strokeWidth = Math.max(this._strokeWidth, 1);

package/dist/_pkgs/affine-gfx-shape/polygon-tool.d.ts

@@ -1,6 +1,25 @@
 import type { PointerEventState } from '../std/index.js';
 import { BaseTool, type GfxController } from '../std/gfx/index.js';
-export type PolygonToolOption = Record<string, unknown>;
+export type PolygonToolOption = {
+    /**
+     * Props the activation stamps on the shape the closed outline produces — the
+     * same seam `ConnectorTool`'s `role` / `style` options are: a framework arms
+     * this tool to draw ITS artefact (a Wardley zone) rather than a plain
+     * polygon, so the element is born typed instead of being converted after the
+     * fact. Absent for the plain polygon tool, which keeps drawing a shape.
+     *
+     * Merged BEFORE the geometry: a framework's description of an artefact
+     * carries the box and the outline it would have been born with, and the
+     * outline the author just drew must win over both.
+     */
+    props?: Record<string, unknown>;
+    /**
+     * Called once the element exists, for the placement an element description
+     * cannot express — a Wardley zone has to be lowered to just above the map it
+     * covers, which depends on what is already on the board.
+     */
+    onCreated?: (gfx: GfxController, id: string) => void;
+};
 /**
  * PolygonTool allows users to draw arbitrary polygons by clicking to place
  * vertices on the edgeless canvas. The polygon is finalised by either:

package/dist/_pkgs/affine-gfx-shape/polygon-tool.js

@@ -228,8 +228,15 @@ export class PolygonTool extends BaseTool {
         const id = this.gfx.surface.addElement({
             type: CanvasElementType.SHAPE,
             shapeType: ShapeType.Polygon,
-            xywh: bound.serialize(),
             radius: 0,
+            // What the activation asked for, if anything — it may change the element
+            // type itself, which is how a framework gets its own artefact out of this
+            // gesture. Spread here so the geometry below always wins: the props of a
+            // framework artefact describe the shape it would have been born with,
+            // outline included, and that outline is exactly what the author just
+            // replaced by drawing.
+            ...this.activatedOption.props,
+            xywh: bound.serialize(),
             vertices: normalizedVertices,
             isClosed: true,
             smoothFlags: smoothFlagsForModel,
@@ -237,6 +244,7 @@ export class PolygonTool extends BaseTool {
                 ? { controlPoints: controlPointsForModel }
                 : {}),
         });
+        this.activatedOption.onCreated?.(this.gfx, id);
         this.std.getOptional(TelemetryProvider)?.track('CanvasElementAdded', {
             control: 'canvas:draw',
             page: 'whiteboard editor',

package/dist/_pkgs/affine-gfx-shape/toolbar/config.js

@@ -1,5 +1,5 @@
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
-import { packColor, } from '../../affine-components/color-picker/index.js';
+import { frameworkPaletteGroups, packColor, } from '../../affine-components/color-picker/index.js';
 import { createTextActions } from '../../affine-gfx-text/index.js';
 import { DefaultTheme, FontFamily, getShapeName, getShapeRadius, getShapeType, isTransparent, LineWidth, MindmapElementModel, resolveColor, ShapeElementModel, ShapeStyle, ShapeType, StrokeStyle, TextFitMode, } from '../../affine-model/index.js';
 import { STYLE_MENU_LABEL, ToolbarModuleExtension, translateKey, } from '../../affine-shared/services/index.js';
@@ -192,11 +192,16 @@ export const shapeToolbarConfig = {
                             .updateElement(model.id, { strokeStyle });
                     }
                 };
+                // The base palette, plus a page per framework whose tooling is on —
+                // opening on the one the selection belongs to (`docs/adr/0027`).
+                const carousel = frameworkPaletteGroups(ctx.std, models, DefaultTheme.Palettes);
                 return html `
           <edgeless-shape-color-picker
             @pickFillColor=${onPickFillColor}
             @pickStrokeColor=${onPickStrokeColor}
             @pickStrokeStyle=${onPickStrokeStyle}
+            .paletteGroups=${carousel.groups}
+            .activeGroupKey=${carousel.activeKey}
             .payload=${{
                     fillColor,
                     strokeColor,

package/dist/_pkgs/affine-gfx-shape/toolbar/palette-color-action.js

@@ -1,5 +1,5 @@
 import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
-import { packColor, } from '../../affine-components/color-picker/index.js';
+import { frameworkPaletteGroups, packColor, } from '../../affine-components/color-picker/index.js';
 import { DefaultTheme, isTransparent, LineWidth, resolveColor, ShapeElementModel, StrokeStyle, } from '../../affine-model/index.js';
 import { getMostCommonValue } from '../../affine-shared/utils/index.js';
 import { html } from 'lit';
@@ -99,12 +99,22 @@ export function paletteColorAction(id, palettes, fillColorFor = (_model, value)
                     crud.updateElement(model.id, props);
                 }
             };
+            // The carousel: the editor palette, then a page per framework whose
+            // tooling is on. A Wardley node resolves to `wardley` and therefore
+            // OPENS on the very swatches `palettes` holds, since the framework
+            // registers that same list (`docs/adr/0027`). With its flag off the
+            // framework contributes no page and the picker opens on the editor
+            // palette — a palette is tooling (`docs/adr/0009`), the colour already
+            // stored is not and does not move.
+            const carousel = frameworkPaletteGroups(ctx.std, models, DefaultTheme.Palettes);
             return html `
         <edgeless-shape-color-picker
           @pickFillColor=${onPickFillColor}
           @pickStrokeColor=${onPickStrokeColor}
           @pickStrokeStyle=${onPickStrokeStyle}
           .palettes=${palettes}
+          .paletteGroups=${carousel.groups}
+          .activeGroupKey=${carousel.activeKey}
           .payload=${{
                 fillColor,
                 strokeColor,

package/dist/_pkgs/affine-gfx-template/builtin/other.js

@@ -258,7 +258,7 @@ const previews = {
 /**
  * A hand-composed template — what is left once the artefacts are derived. The
  * seeds a template writes into the document go through the translation seam
- * at placement (ADR 0016); `content` stays the English build, and `localize`
+ * at placement (ADR 0023); `content` stays the English build, and `localize`
  * rebuilds the same snapshot with translated seeds.
  */
 function t(name, preview, build) {

package/dist/_pkgs/affine-gfx-template/snapshot-from-action.js

@@ -1,7 +1,5 @@
-import { EdgelessCRUDIdentifier } from '../affine-block-surface/index.js';
-import { TranslationProvider } from '../affine-shared/services/index.js';
+import { recordAction } from '../affine-block-surface/index.js';
 import { Bound } from '../global/gfx/index.js';
-import { generateKeyBetween, GfxControllerIdentifier } from '../std/gfx/index.js';
 import * as Y from 'yjs';
 import { makeTemplateSnapshot, surfaceText, surfaceYMap, } from './make-snapshot.js';
 /**
@@ -35,124 +33,39 @@ function materialize(text) {
  * the action writes its English fallbacks.
  */
 export function snapshotFromAction(run, name, host) {
-    const elements = new Map();
-    let n = 0;
-    let lastIndex = null;
-    const nextIndex = () => (lastIndex = generateKeyBetween(lastIndex, null));
-    const addElement = (props) => {
-        const id = `el-${n++}`;
-        const record = {};
-        for (const [key, value] of Object.entries(props)) {
-            if (value !== undefined)
-                record[key] = value;
-        }
-        record['id'] = id;
-        // ponytail: the Y conversions are hard-coded (`text`, and a group's
-        // `children` / `title`) instead of asking each element class for its own
-        // `propsToY`. Ceiling: it covers every prop the framework actions pass
-        // today. Upgrade path: run the real `propsToY` once the element-ctor map is
-        // reachable without a live surface.
-        const text = record['text'];
-        if (typeof text === 'string')
-            record['text'] = surfaceText(text);
-        else if (text instanceof Y.Text)
-            record['text'] = surfaceText(materialize(text));
-        if (record['type'] === 'group') {
-            const children = record['children'];
-            if (children && typeof children === 'object') {
-                record['children'] = surfaceYMap(Object.fromEntries(Object.keys(children).map(key => [key, true])));
-            }
-            const title = record['title'];
-            if (typeof title === 'string')
-                record['title'] = surfaceText(title);
-            else if (title instanceof Y.Text)
-                record['title'] = surfaceText(materialize(title));
-        }
-        if (record['index'] === undefined)
-            record['index'] = nextIndex();
-        // The model members an action reads back off `getElementById`, kept
-        // non-enumerable so they never leak into the snapshot.
-        Object.defineProperties(record, {
-            group: { value: null },
-            deserializedXYWH: {
-                get: () => typeof record['xywh'] === 'string'
-                    ? Bound.deserialize(record['xywh'])
-                    : null,
-            },
-        });
-        elements.set(id, record);
-        return id;
-    };
-    const records = () => [...elements.values()];
-    const surface = {
-        addElement,
-        getElementById: (id) => elements.get(id) ?? null,
-        getElementsByType: (type) => records().filter(el => el['type'] === type),
-        get elementModels() {
-            return records();
-        },
-    };
-    const gfx = {
-        surface,
-        viewport: { centerX: 0, centerY: 0, zoom: 1, center: { x: 0, y: 0 } },
-        doc: { captureSync: () => { } },
-        selection: { set: () => { }, selectedElements: [] },
-        tool: { setTool: () => { } },
-        layer: {
-            generateIndex: () => nextIndex(),
-            getReorderedIndex: (_model, direction) => {
-                const sorted = records()
-                    .map(el => String(el['index']))
-                    .sort();
-                return direction === 'back'
-                    ? generateKeyBetween(null, sorted[0] ?? null)
-                    : generateKeyBetween(sorted[sorted.length - 1] ?? null, null);
-            },
-            get canvasElements() {
-                return records();
-            },
-        },
-        std: null,
-    };
-    const crud = {
-        addElement: (type, props) => addElement({ ...props, type }),
-    };
-    const std = {
-        get: (identifier) => {
-            if (identifier === GfxControllerIdentifier)
-                return gfx;
-            if (identifier === EdgelessCRUDIdentifier)
-                return crud;
-            throw new Error(`snapshotFromAction: unsupported service "${identifier?.identifierName ?? String(identifier)}"`);
-        },
-        getOptional: (identifier) => identifier === TranslationProvider
-            ? host?.getOptional(TranslationProvider)
-            : undefined,
-        command: {
-            // Really run the command, so a group built by `createGroupCommand` is
-            // whatever that command says a group is — no second definition here.
-            exec: (cmd, payload) => {
-                let out;
-                cmd({ std: gfx.std, ...payload }, r => {
-                    out = r;
-                });
-                return [{}, out ?? {}];
-            },
-        },
-        store: {
-            readonly: false,
-            captureSync: () => { },
-            id: 'doc:template',
-            workspace: { meta: { getDocMeta: () => undefined } },
-        },
-    };
-    gfx.std = std;
-    run(gfx.std);
-    if (elements.size === 0) {
+    const { records } = recordAction(run, { host, encode: toSnapshotProps });
+    if (records.length === 0) {
         throw new Error('snapshotFromAction: the action added no element (a tool-arming command?)');
     }
-    normalizeToOrigin(records());
-    return makeTemplateSnapshot(Object.fromEntries(elements), name);
+    normalizeToOrigin(records);
+    return makeTemplateSnapshot(Object.fromEntries(records.map(record => [String(record['id']), record])), name);
+}
+/**
+ * The Y-carrying props, in the serialized form a snapshot holds them in.
+ *
+ * ponytail: the conversions are hard-coded (`text`, and a group's `children` /
+ * `title`) instead of asking each element class for its own `propsToY`.
+ * Ceiling: it covers every prop the framework actions pass today. Upgrade path:
+ * run the real `propsToY` once the element-ctor map is reachable without a live
+ * surface.
+ */
+function toSnapshotProps(record) {
+    const text = record['text'];
+    if (typeof text === 'string')
+        record['text'] = surfaceText(text);
+    else if (text instanceof Y.Text)
+        record['text'] = surfaceText(materialize(text));
+    if (record['type'] === 'group') {
+        const children = record['children'];
+        if (children && typeof children === 'object') {
+            record['children'] = surfaceYMap(Object.fromEntries(Object.keys(children).map(key => [key, true])));
+        }
+        const title = record['title'];
+        if (typeof title === 'string')
+            record['title'] = surfaceText(title);
+        else if (title instanceof Y.Text)
+            record['title'] = surfaceText(materialize(title));
+    }
 }
 /** The connector endpoints that carry a free position rather than an anchor. */
 function freeEndpoints(el) {

package/dist/_pkgs/affine-gfx-template/toolbar/template-type.d.ts

@@ -46,7 +46,7 @@ export type Template = {
      * Rebuild {@link content} in the inserting editor's language — the seeds a
      * template writes into the document (a component's name, a lane's title) go
      * through the translation seam at placement, like a creation action's
-     * (ADR 0016). Called once per insertion; without it `content` is inserted
+     * (ADR 0023). Called once per insertion; without it `content` is inserted
      * as is.
      *
      * With no `TranslationProvider` registered it must return exactly

package/dist/_pkgs/affine-gfx-text/dblclick-add-edgeless-text.d.ts

@@ -1,4 +1,16 @@
-import { InteractivityExtension } from '../std/gfx/index.js';
+import { type GfxController, InteractivityExtension } from '../std/gfx/index.js';
+/**
+ * Whether a double click at this model point lands on nothing at all.
+ *
+ * Two layers have to agree, because they answer different questions: the model
+ * hit test (`getElementByPoint`) answers "may I be selected here?", the view
+ * router answers "is this point mine?". Since framework backgrounds became
+ * border-only for picking (#194), their axis labels are a place where the two
+ * disagree — the model calls the label empty canvas while the view is opening
+ * its rename editor there, and dropping a text block on top blurs that editor
+ * shut before the user can type.
+ */
+export declare function isEmptyCanvasAt(gfx: GfxController, x: number, y: number): boolean;
 export declare class DblClickAddEdgelessText extends InteractivityExtension {
     static key: string;
     mounted(): void;

package/dist/_pkgs/affine-gfx-text/dblclick-add-edgeless-text.js

@@ -1,7 +1,23 @@
 import { FeatureFlagService, TelemetryProvider, } from '../affine-shared/services/index.js';
-import { InteractivityExtension, } from '../std/gfx/index.js';
+import { InteractivityExtension, InteractivityIdentifier, } from '../std/gfx/index.js';
 import { insertEdgelessTextCommand } from './commands/index.js';
 import { addText } from './edgeless-text-editor.js';
+/**
+ * Whether a double click at this model point lands on nothing at all.
+ *
+ * Two layers have to agree, because they answer different questions: the model
+ * hit test (`getElementByPoint`) answers "may I be selected here?", the view
+ * router answers "is this point mine?". Since framework backgrounds became
+ * border-only for picking (#194), their axis labels are a place where the two
+ * disagree — the model calls the label empty canvas while the view is opening
+ * its rename editor there, and dropping a text block on top blurs that editor
+ * shut before the user can type.
+ */
+export function isEmptyCanvasAt(gfx, x, y) {
+    if (gfx.getElementByPoint(x, y))
+        return false;
+    return !gfx.std.getOptional(InteractivityIdentifier)?.hasViewAt(x, y);
+}
 export class DblClickAddEdgelessText extends InteractivityExtension {
     static { this.key = 'dbl-click-add-edgeless-text'; }
     mounted() {
@@ -10,12 +26,11 @@ export class DblClickAddEdgelessText extends InteractivityExtension {
             const textFlag = this.std.store
                 .get(FeatureFlagService)
                 .getFlag('enable_edgeless_text');
-            const picked = this.gfx.getElementByPoint(...this.gfx.viewport.toModelCoord(e.x, e.y));
-            if (picked) {
+            const [x, y] = this.gfx.viewport.toModelCoord(e.x, e.y);
+            if (!isEmptyCanvasAt(this.gfx, x, y)) {
                 return;
             }
             if (textFlag) {
-                const [x, y] = this.gfx.viewport.toModelCoord(e.x, e.y);
                 this.std.command.exec(insertEdgelessTextCommand, { x, y });
             }
             else {

package/dist/_pkgs/affine-gfx-text/edgeless-text-editor.d.ts

@@ -9,6 +9,46 @@ export declare function mountTextElementEditor(textElement: TextElementModel, ed
  * Canvas Text has been deprecated
  */
 export declare function addText(edgeless: BlockComponent, event: PointerEventState): void;
+/**
+ * What the editor does with a canvas text the author committed EMPTY: delete it,
+ * or leave it standing.
+ *
+ * ## Why anything survives being emptied
+ *
+ * A free canvas text emptied of its words IS nothing, and deleting it is what
+ * keeps an invisible, selectable box off the board. That was the only rule until
+ * the PO's recette of 14/09/2026 found what it costs a COMPARTMENT: emptying a
+ * classifier's title deleted the `uml:name` tier out of its group, and the next
+ * double-click on the body fell through to the SHAPE's own inner text
+ * (`UmlNodeView`), which R16 keeps empty and no framework renderer paints —
+ * "je n'arrive pas à entrer dans l'édition de texte".
+ *
+ * ## …and why a `role` alone is not the test
+ *
+ * A role says the element means something to a framework. It does NOT say the
+ * element is a tier of a composite: a Wardley `wardley:label` and a BPMN name
+ * are roled texts that float BESIDE their artefact, sized to their own words,
+ * and one emptied to nothing leaves exactly the invisible box the deletion rule
+ * exists to remove — with no placeholder drawn over it and no layout to put it
+ * back.
+ *
+ * A compartment tier is the one that has both halves: a `role`, and
+ * `hasMaxWidth` — a FIXED width, given at creation by every framework that lays
+ * tiers out (`uml/presets.ts`, `c4/actions.ts`), because a tier's width is its
+ * compartment's and not its content's. That fixed width is also, and not by
+ * coincidence, what leaves a full-width hit box for the next double-click to
+ * land on when the words are gone.
+ *
+ * Pure and total, so it can be asked without an editor, an element model or a
+ * document.
+ */
+export declare function emptiedTextIsDeleted(element: {
+    text: {
+        length: number;
+    };
+    role?: string;
+    hasMaxWidth?: boolean;
+}): boolean;
 declare const EdgelessTextEditor_base: typeof ShadowlessElement & import("../global/utils/types.js").Constructor<import("../global/lit/with-disposable.js").DisposableClass>;
 export declare class EdgelessTextEditor extends EdgelessTextEditor_base {
     get crud(): import("../affine-block-surface/index.js").EdgelessCRUDExtension;
@@ -20,6 +60,7 @@ export declare class EdgelessTextEditor extends EdgelessTextEditor_base {
     static styles: import("lit").CSSResult;
     private _isComposition;
     private _keeping;
+    private _removing;
     private readonly _updateRect;
     get inlineEditor(): import("../affine-shared/types/index.js").AffineInlineEditor | null;
     get inlineEditorContainer(): import("../std/inline/inline-editor.js").InlineRootElement<import("../affine-shared/types/index.js").AffineTextAttributes> | null | undefined;

package/dist/_pkgs/affine-gfx-text/edgeless-text-editor.js

@@ -97,6 +97,44 @@ export function addText(edgeless, event) {
         }
     }
 }
+/**
+ * What the editor does with a canvas text the author committed EMPTY: delete it,
+ * or leave it standing.
+ *
+ * ## Why anything survives being emptied
+ *
+ * A free canvas text emptied of its words IS nothing, and deleting it is what
+ * keeps an invisible, selectable box off the board. That was the only rule until
+ * the PO's recette of 14/09/2026 found what it costs a COMPARTMENT: emptying a
+ * classifier's title deleted the `uml:name` tier out of its group, and the next
+ * double-click on the body fell through to the SHAPE's own inner text
+ * (`UmlNodeView`), which R16 keeps empty and no framework renderer paints —
+ * "je n'arrive pas à entrer dans l'édition de texte".
+ *
+ * ## …and why a `role` alone is not the test
+ *
+ * A role says the element means something to a framework. It does NOT say the
+ * element is a tier of a composite: a Wardley `wardley:label` and a BPMN name
+ * are roled texts that float BESIDE their artefact, sized to their own words,
+ * and one emptied to nothing leaves exactly the invisible box the deletion rule
+ * exists to remove — with no placeholder drawn over it and no layout to put it
+ * back.
+ *
+ * A compartment tier is the one that has both halves: a `role`, and
+ * `hasMaxWidth` — a FIXED width, given at creation by every framework that lays
+ * tiers out (`uml/presets.ts`, `c4/actions.ts`), because a tier's width is its
+ * compartment's and not its content's. That fixed width is also, and not by
+ * coincidence, what leaves a full-width hit box for the next double-click to
+ * land on when the words are gone.
+ *
+ * Pure and total, so it can be asked without an editor, an element model or a
+ * document.
+ */
+export function emptiedTextIsDeleted(element) {
+    if (element.text.length !== 0)
+        return false;
+    return !(element.role !== undefined && element.hasMaxWidth === true);
+}
 let EdgelessTextEditor = (() => {
     let _classSuper = WithDisposable(ShadowlessElement);
     let _std_decorators;
@@ -203,7 +241,12 @@ let EdgelessTextEditor = (() => {
                 this.disposables.add(dispatcher.add('doubleClick', () => true));
                 this.disposables.add(() => {
                     element.display = true;
-                    if (element.text.length === 0) {
+                    // An emptied COMPARTMENT TIER stays, at its compartment's box,
+                    // showing the placeholder its framework draws and answering the next
+                    // double-click; anything else emptied goes. The whole rule, and why it
+                    // is those two properties and not one, is on
+                    // {@link emptiedTextIsDeleted}.
+                    if (emptiedTextIsDeleted(element)) {
                         this.crud.deleteElements([element]);
                     }
                     this.gfx.selection.set({
@@ -213,7 +256,18 @@ let EdgelessTextEditor = (() => {
                 });
                 if (!this.inlineEditorContainer)
                     return;
-                this.disposables.addFromEvent(this.inlineEditorContainer, 'blur', () => !this._keeping && this.remove());
+                this.disposables.addFromEvent(this.inlineEditorContainer, 'blur', () => {
+                    // Re-entrant, and the connector label editor already says why:
+                    // Chrome fires the focused child's blur SYNCHRONOUSLY inside
+                    // `remove()`, before the node is detached, and the commit in
+                    // `disconnectedCallback` moves the focus again. Without the flag the
+                    // handler removes a node whose removal is in progress — a
+                    // `NotFoundError` out of a listener nobody is awaiting.
+                    if (this._keeping || this._removing)
+                        return;
+                    this._removing = true;
+                    this.remove();
+                });
                 this.disposables.addFromEvent(this.inlineEditorContainer, 'compositionstart', () => {
                     this._isComposition = true;
                     this.requestUpdate();
@@ -353,6 +407,7 @@ let EdgelessTextEditor = (() => {
             super(...arguments);
             this._isComposition = false;
             this._keeping = false;
+            this._removing = false;
             this._updateRect = () => {
                 const element = this.element;
                 if (!element || !this.inlineEditorContainer)

package/dist/_pkgs/affine-gfx-text/toolbar/actions.d.ts

@@ -1,6 +1,12 @@
 import { type SurfaceTextModelMap, type TextStyleProps } from '../../affine-model/index.js';
 import { type ToolbarContext } from '../../affine-shared/services/index.js';
-export declare function createTextActions<K extends abstract new (...args: any) => any, T extends keyof SurfaceTextModelMap>(klass: K, type: T, update?: (ctx: ToolbarContext, model: InstanceType<K>, props: Partial<TextStyleProps>) => void, mapInto?: (model: InstanceType<K>) => TextStyleProps, stash?: <P extends keyof TextStyleProps>(model: InstanceType<K>, type: 'stash' | 'pop', field: P) => void): [{
+/**
+ * What the dropdowns read off a selected model. `fontSize` is optional because
+ * `affine:edgeless-text` has no such prop — it scales instead, which is why the
+ * `d.font-size` action skips that type.
+ */
+type ReadableTextStyleProps = Omit<TextStyleProps, 'fontSize'> & Partial<Pick<TextStyleProps, 'fontSize'>>;
+export declare function createTextActions<K extends abstract new (...args: any) => any, T extends keyof SurfaceTextModelMap>(klass: K, type: T, update?: (ctx: ToolbarContext, model: InstanceType<K>, props: Partial<TextStyleProps>) => void, mapInto?: (model: InstanceType<K>) => ReadableTextStyleProps, stash?: <P extends keyof TextStyleProps>(model: InstanceType<K>, type: 'stash' | 'pop', field: P) => void): [{
     readonly id: "a.font";
     readonly content: (ctx: ToolbarContext) => import("lit-html").TemplateResult<1> | null;
 }, {
@@ -17,3 +23,4 @@ export declare function createTextActions<K extends abstract new (...args: any)
     readonly id: "e.alignment";
     readonly content: (ctx: ToolbarContext) => import("lit-html").TemplateResult<1> | null;
 }];
+export {};

package/dist/_pkgs/affine-gfx-text/toolbar/actions.js

@@ -1,5 +1,5 @@
 import { EdgelessCRUDIdentifier, TextUtils } from '../../affine-block-surface/index.js';
-import { packColor, } from '../../affine-components/color-picker/index.js';
+import { frameworkPaletteGroups, packColor, } from '../../affine-components/color-picker/index.js';
 import { EditorChevronDown } from '../../affine-components/toolbar/index.js';
 import { DefaultTheme, FontFamily, FontStyle, FontWeight, resolveColor, TextAlign, } from '../../affine-model/index.js';
 import { translateKey, } from '../../affine-shared/services/index.js';
@@ -10,7 +10,7 @@ import { signal } from '@preact/signals-core';
 import { html } from 'lit';
 import { styleMap } from 'lit/directives/style-map.js';
 import { isFontStyleSupported, isFontWeightSupported, } from '../element-renderer/utils.js';
-import { TEXT_ALIGN_CENTER, TEXT_ALIGN_LEFT, TEXT_ALIGN_RIGHT, TEXT_TOOLBAR_ALIGNMENT, TEXT_TOOLBAR_FONT, TEXT_TOOLBAR_FONT_STYLE, TEXT_TOOLBAR_FONT_STYLE_ITALIC, TEXT_TOOLBAR_FONT_WEIGHT_LIGHT, TEXT_TOOLBAR_FONT_WEIGHT_REGULAR, TEXT_TOOLBAR_FONT_WEIGHT_SEMIBOLD, TEXT_TOOLBAR_FONT_SIZE, TEXT_TOOLBAR_TEXT_COLOR, } from '../translations.js';
+import { TEXT_ALIGN_CENTER, TEXT_ALIGN_LEFT, TEXT_ALIGN_RIGHT, TEXT_TOOLBAR_ALIGNMENT, TEXT_TOOLBAR_FONT, TEXT_TOOLBAR_FONT_STYLE, TEXT_TOOLBAR_FONT_STYLE_ITALIC, TEXT_TOOLBAR_FONT_WEIGHT_BOLD, TEXT_TOOLBAR_FONT_WEIGHT_LIGHT, TEXT_TOOLBAR_FONT_WEIGHT_REGULAR, TEXT_TOOLBAR_FONT_WEIGHT_SEMIBOLD, TEXT_TOOLBAR_FONT_SIZE, TEXT_TOOLBAR_TEXT_COLOR, } from '../translations.js';
 const FONT_WEIGHT_LIST = [
     {
         key: 'Light',
@@ -27,6 +27,11 @@ const FONT_WEIGHT_LIST = [
         keyWording: TEXT_TOOLBAR_FONT_WEIGHT_SEMIBOLD,
         value: FontWeight.SemiBold,
     },
+    {
+        key: 'Bold',
+        keyWording: TEXT_TOOLBAR_FONT_WEIGHT_BOLD,
+        value: FontWeight.Bold,
+    },
 ];
 const FONT_STYLE_LIST = [
     {
@@ -167,6 +172,9 @@ export function createTextActions(klass, type, update = (ctx, model, props) => c
                             break;
                     }
                 };
+                // A label on a framework board opens on that framework's hues; the
+                // text palette of the editor stays page one (`docs/adr/0027`).
+                const carousel = frameworkPaletteGroups(ctx.std, models, palettes);
                 return html `
           <edgeless-color-picker-button
             class="text-color"
@@ -179,6 +187,8 @@ export function createTextActions(klass, type, update = (ctx, model, props) => c
             .hollowCircle=${true}
             .originalColor=${originalColor}
             .palettes=${palettes}
+            .paletteGroups=${carousel.groups}
+            .activeGroupKey=${carousel.activeKey}
             .enableCustomColor=${enableCustomColor}
           >
           </edgeless-color-picker-button>

package/dist/_pkgs/affine-gfx-text/translations.d.ts

@@ -11,6 +11,7 @@ export declare const TEXT_TOOLBAR_FONT_SIZE: ChromeWording;
 export declare const TEXT_TOOLBAR_FONT_WEIGHT_LIGHT: ChromeWording;
 export declare const TEXT_TOOLBAR_FONT_WEIGHT_REGULAR: ChromeWording;
 export declare const TEXT_TOOLBAR_FONT_WEIGHT_SEMIBOLD: ChromeWording;
+export declare const TEXT_TOOLBAR_FONT_WEIGHT_BOLD: ChromeWording;
 export declare const TEXT_TOOLBAR_FONT_STYLE_ITALIC: ChromeWording;
 export declare const TEXT_TOOLBAR_FONT: ChromeWording;
 export declare const TEXT_TOOLBAR_TEXT_COLOR: ChromeWording;

package/dist/_pkgs/affine-gfx-text/translations.js

@@ -1,4 +1,4 @@
-import { FONT_SIZE_LABEL, FONT_STYLE_ITALIC, FONT_WEIGHT_LIGHT, FONT_WEIGHT_REGULAR, FONT_WEIGHT_SEMIBOLD, } from '../affine-shared/services/index.js';
+import { FONT_SIZE_LABEL, FONT_STYLE_ITALIC, FONT_WEIGHT_BOLD, FONT_WEIGHT_LIGHT, FONT_WEIGHT_REGULAR, FONT_WEIGHT_SEMIBOLD, } from '../affine-shared/services/index.js';
 /**
  * The shared text toolbar's own wordings (`createTextActions`, rendered by
  * every framework that draws real text — shape, mindmap, connector,
@@ -11,6 +11,7 @@ export const TEXT_TOOLBAR_FONT_SIZE = FONT_SIZE_LABEL;
 export const TEXT_TOOLBAR_FONT_WEIGHT_LIGHT = FONT_WEIGHT_LIGHT;
 export const TEXT_TOOLBAR_FONT_WEIGHT_REGULAR = FONT_WEIGHT_REGULAR;
 export const TEXT_TOOLBAR_FONT_WEIGHT_SEMIBOLD = FONT_WEIGHT_SEMIBOLD;
+export const TEXT_TOOLBAR_FONT_WEIGHT_BOLD = FONT_WEIGHT_BOLD;
 export const TEXT_TOOLBAR_FONT_STYLE_ITALIC = FONT_STYLE_ITALIC;
 export const TEXT_TOOLBAR_FONT = [
     'com.labre.text-toolbar.font',

package/dist/_pkgs/affine-inline-preset/markdown.js

@@ -195,14 +195,18 @@ export const CodeExtension = InlineMarkdownExtension({
 });
 // typographic replacement: word -- + space => word — + space
 // not convert: --- + space (divider shortcut), --flag + space, inside inline code
+// an odd number of backticks before the dashes means a code span is still open:
+// the closing backtick has not run yet, so the dashes are code in the making
 export const EmDashExtension = InlineMarkdownExtension({
     name: 'em-dash',
     pattern: /(?:^|[^-])--\s$/,
-    action: ({ inlineEditor, inlineRange, undoManager }) => {
+    action: ({ inlineEditor, inlineRange, prefixText, undoManager }) => {
         const dashes = { index: inlineRange.index - 3, length: 2 };
         const format = inlineEditor.getFormat(dashes);
         if (format.code)
             return;
+        if ((prefixText.match(/`/g) ?? []).length % 2 === 1)
+            return;
         undoManager.stopCapturing();
         inlineEditor.insertText(dashes, '—', format);
         inlineEditor.setInlineRange({