@formicoidea/labre-core 0.41.0 → 0.42.0

package/dist/_pkgs/affine-model/consts/connector.d.ts

@@ -2,14 +2,40 @@ export declare enum ConnectorEndpoint {
     Front = "Front",
     Rear = "Rear"
 }
+/**
+ * The endpoint head painted at each end of a connector.
+ *
+ * **These string values are PERSISTED.** Every connector stores two of them
+ * (`frontEndpointStyle` / `rearEndpointStyle`, see
+ * `../elements/connector/connector.ts`), so the enum is **append-only**: a
+ * member may be added, never renamed, never removed, and never given a
+ * different string value. Renaming one would silently turn every stored
+ * connector that carries it into an unknown style.
+ *
+ * **Adding a member is safe in both directions.** The canvas `renderEndpoint`
+ * switch (`@labre/affine-gfx-connector`) and the DOM renderer's
+ * `createArrowMarker` both have **no `default` branch** on purpose: a client
+ * built before a member was added simply paints no head for it. The connector
+ * itself, its geometry, its label and its bindings all still load and still
+ * round-trip — degraded, never broken. The reverse is free: an older document
+ * only ever carries members that already existed.
+ *
+ * `TriangleHollow` and `DiamondHollow` are the UML 2.5.1 heads — a hollow
+ * closed triangle for generalization and realization, a hollow diamond for
+ * shared aggregation. They are the same geometry as `Triangle` / `Diamond`,
+ * filled with the notation card fill instead of the stroke colour; see
+ * `docs/adr/0016-hollow-endpoint-styles.md`.
+ */
 export declare enum PointStyle {
     Arrow = "Arrow",
     Circle = "Circle",
     Diamond = "Diamond",
     None = "None",
-    Triangle = "Triangle"
+    Triangle = "Triangle",
+    TriangleHollow = "TriangleHollow",
+    DiamondHollow = "DiamondHollow"
 }
-export declare const PointStyleMap: Record<PointStyle, "Arrow" | "Circle" | "Diamond" | "None" | "Triangle">;
+export declare const PointStyleMap: Record<PointStyle, "Arrow" | "Circle" | "Diamond" | "None" | "Triangle" | "TriangleHollow" | "DiamondHollow">;
 export declare const DEFAULT_FRONT_ENDPOINT_STYLE = PointStyle.None;
 export declare const DEFAULT_REAR_ENDPOINT_STYLE = PointStyle.Arrow;
 export declare const CONNECTOR_LABEL_MAX_WIDTH = 280;

package/dist/_pkgs/affine-model/consts/connector.js

@@ -4,6 +4,30 @@ export var ConnectorEndpoint;
     ConnectorEndpoint["Front"] = "Front";
     ConnectorEndpoint["Rear"] = "Rear";
 })(ConnectorEndpoint || (ConnectorEndpoint = {}));
+/**
+ * The endpoint head painted at each end of a connector.
+ *
+ * **These string values are PERSISTED.** Every connector stores two of them
+ * (`frontEndpointStyle` / `rearEndpointStyle`, see
+ * `../elements/connector/connector.ts`), so the enum is **append-only**: a
+ * member may be added, never renamed, never removed, and never given a
+ * different string value. Renaming one would silently turn every stored
+ * connector that carries it into an unknown style.
+ *
+ * **Adding a member is safe in both directions.** The canvas `renderEndpoint`
+ * switch (`@labre/affine-gfx-connector`) and the DOM renderer's
+ * `createArrowMarker` both have **no `default` branch** on purpose: a client
+ * built before a member was added simply paints no head for it. The connector
+ * itself, its geometry, its label and its bindings all still load and still
+ * round-trip — degraded, never broken. The reverse is free: an older document
+ * only ever carries members that already existed.
+ *
+ * `TriangleHollow` and `DiamondHollow` are the UML 2.5.1 heads — a hollow
+ * closed triangle for generalization and realization, a hollow diamond for
+ * shared aggregation. They are the same geometry as `Triangle` / `Diamond`,
+ * filled with the notation card fill instead of the stroke colour; see
+ * `docs/adr/0016-hollow-endpoint-styles.md`.
+ */
 export var PointStyle;
 (function (PointStyle) {
     PointStyle["Arrow"] = "Arrow";
@@ -11,6 +35,8 @@ export var PointStyle;
     PointStyle["Diamond"] = "Diamond";
     PointStyle["None"] = "None";
     PointStyle["Triangle"] = "Triangle";
+    PointStyle["TriangleHollow"] = "TriangleHollow";
+    PointStyle["DiamondHollow"] = "DiamondHollow";
 })(PointStyle || (PointStyle = {}));
 export const PointStyleMap = createEnumMap(PointStyle);
 export const DEFAULT_FRONT_ENDPOINT_STYLE = PointStyle.None;

package/dist/_pkgs/affine-model/elements/bpmn/pool.js

@@ -98,7 +98,7 @@ let BpmnPoolElementModel = (() => {
             _name_decorators = [field('Pool')];
             _resizeEnabled_decorators = [field(true)];
             _rotate_decorators = [field(0)];
-            _xywh_decorators = [field()];
+            _xywh_decorators = [field('[0,0,0,0]')];
             _lanes_decorators = [field()];
             __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
             __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);

package/dist/_pkgs/affine-model/elements/brush/brush.js

@@ -109,7 +109,7 @@ let BrushElementModel = (() => {
                             ...(instance.points[i][2] !== undefined ? [instance.points[i][2]] : []),
                         ]),
                     };
-                }), field()];
+                }), field('[0,0,0,0]')];
             __esDecorate(this, null, _color_decorators, { kind: "accessor", name: "color", static: false, private: false, access: { has: obj => "color" in obj, get: obj => obj.color, set: (obj, value) => { obj.color = value; } }, metadata: _metadata }, _color_initializers, _color_extraInitializers);
             __esDecorate(this, null, _lineWidth_decorators, { kind: "accessor", name: "lineWidth", static: false, private: false, access: { has: obj => "lineWidth" in obj, get: obj => obj.lineWidth, set: (obj, value) => { obj.lineWidth = value; } }, metadata: _metadata }, _lineWidth_initializers, _lineWidth_extraInitializers);
             __esDecorate(this, null, _points_decorators, { kind: "accessor", name: "points", static: false, private: false, access: { has: obj => "points" in obj, get: obj => obj.points, set: (obj, value) => { obj.points = value; } }, metadata: _metadata }, _points_initializers, _points_extraInitializers);

package/dist/_pkgs/affine-model/elements/c4/board.js

@@ -93,7 +93,7 @@ let C4BoardElementModel = (() => {
             _name_decorators = [field('C4 diagram')];
             _resizeEnabled_decorators = [field(true)];
             _rotate_decorators = [field(0)];
-            _xywh_decorators = [field()];
+            _xywh_decorators = [field('[0,0,0,0]')];
             _level_decorators = [field()];
             __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
             __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);

package/dist/_pkgs/affine-model/elements/c4/boundary.js

@@ -67,7 +67,7 @@ let C4BoundaryElementModel = (() => {
             _name_decorators = [field('Boundary')];
             _resizeEnabled_decorators = [field(true)];
             _rotate_decorators = [field(0)];
-            _xywh_decorators = [field()];
+            _xywh_decorators = [field('[0,0,0,0]')];
             _variant_decorators = [field()];
             __esDecorate(this, null, _name_decorators, { kind: "accessor", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
             __esDecorate(this, null, _resizeEnabled_decorators, { kind: "accessor", name: "resizeEnabled", static: false, private: false, access: { has: obj => "resizeEnabled" in obj, get: obj => obj.resizeEnabled, set: (obj, value) => { obj.resizeEnabled = value; } }, metadata: _metadata }, _resizeEnabled_initializers, _resizeEnabled_extraInitializers);

package/dist/_pkgs/affine-model/elements/connector/connector.d.ts

@@ -5,6 +5,7 @@ import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
 import * as Y from 'yjs';
 import { ConnectorLabelOffsetAnchor, ConnectorMode, type PointStyle, StrokeStyle, type TextStyleProps } from '../../consts/index.js';
 import { type Color } from '../../themes/index.js';
+import { type ConnectorLabelEnd } from './end-label.js';
 export type SerializedConnection = {
     id?: string;
     position?: `[${number},${number}]` | PointLocation;
@@ -30,6 +31,16 @@ export type ConnectorLabelProps = {
     labelOffset?: ConnectorLabelOffsetProps;
     labelStyle?: TextStyleProps;
     labelConstraints?: ConnectorLabelConstraintsProps;
+    /**
+     * The two END labels — a multiplicity, a role name, a qualifier — each
+     * anchored beside the endpoint it belongs to. See ADR 0020; they are FLAT
+     * rather than two nested records for the reason spelled out on the
+     * accessors.
+     */
+    sourceLabel?: Y.Text;
+    sourceLabelXYWH?: XYWH;
+    targetLabel?: Y.Text;
+    targetLabelXYWH?: XYWH;
 };
 export type SerializedConnectorElement = SerializedElement & {
     source: SerializedConnection;
@@ -78,6 +89,73 @@ export declare class ConnectorElementModel extends GfxPrimitiveElementModel<Conn
     getPointByOffsetDistance(offsetDistance?: number, bounds?: Bound): IVec;
     getRelativePointLocation(point: IVec): PointLocation;
     hasLabel(): boolean;
+    /** The content of one end's label, or `undefined` when it has none. */
+    endLabelText(end: ConnectorLabelEnd): Y.Text | undefined;
+    /** The box of one end's label, or `undefined` when nothing placed it yet. */
+    endLabelXYWH(end: ConnectorLabelEnd): XYWH | undefined;
+    /**
+     * Whether one end carries a label that should be PAINTED — the end-label
+     * twin of `hasLabel()`, gated on the same `labelDisplay` (one switch hides
+     * every caption on a connector, which is what the toolbar's toggle means)
+     * and on `endLabelEditing` instead of `labelEditing`, so mounting the editor
+     * on one end does not blank the other two labels.
+     */
+    hasEndLabel(end: ConnectorLabelEnd): boolean;
+    hasSourceLabel(): boolean;
+    hasTargetLabel(): boolean;
+    /** The boxes of the end labels that are currently painted, in end order. */
+    endLabelBoxes(): XYWH[];
+    endLabelIncludesPoint(end: ConnectorLabelEnd, point: IVec): boolean;
+    sourceLabelIncludesPoint(point: IVec): boolean;
+    targetLabelIncludesPoint(point: IVec): boolean;
+    /**
+     * Whether a point is reaching for one of the ENDS — the arrowhead, and the
+     * label that belongs beside it whether or not it exists yet.
+     *
+     * ## Why a hairline has to claim more than itself
+     *
+     * A connector is a stroke a few units wide, so its hit test is the line and
+     * nothing else — and an end label is the one thing on a connector that a user
+     * aims at BEFORE it exists (`docs/adr/0018`: they aim at the arrowhead). The
+     * picker that turns a double-click into "the source label" was written
+     * generously for exactly that, and it never got the chance: past `8` units off
+     * the stroke (plus half its width when the caller asks for a threshold —
+     * {@link includesPoint}'s own tolerance) nothing answered here, so the event
+     * reached no view at all and the editor's double-click-on-empty-canvas handler
+     * dropped a text block at the arrowhead instead. A text box appears, it is not
+     * the label, and the contextual menu's own entry works — which is precisely
+     * what the PO reported on 14/09/2026.
+     *
+     * ## …and why only a connector a FRAMEWORK typed claims it
+     *
+     * A `CONNECTOR_END_LABEL_GRAB` disc around each endpoint is a large
+     * thing to take out of the canvas, and the only gesture that needs it is the
+     * one that opens an END label — which is a notation's caption, never a plain
+     * arrow's. A connector carrying a `role` is exactly a connector some framework
+     * wrote (`uml:association`, `bpmn:sequenceFlow`); a generalist one keeps the
+     * hairline it has always had, so a double-click beside a whiteboard arrow
+     * still means "add text here" and a click there still reaches whatever is
+     * under it.
+     *
+     * ## …and why it gives the bound element right of way
+     *
+     * An endpoint sits ON the border of the node it is attached to, so half of
+     * every grab disc is INSIDE that node — and a node's body is the target of its
+     * own gestures (a UML classifier opens its name compartment there). Claiming
+     * that half would take the gesture away from the artefact and give it to the
+     * line touching it. So the disc stops at the bound element's own box, and what
+     * is left is the half the notation writes a multiplicity in: outside the box,
+     * beside the arrowhead.
+     *
+     * Resolved through the surface rather than remembered, and BOTH ways: a
+     * canvas element by id, and a BLOCK — a note, an image, an embed, a frame —
+     * through the store, because those are ends a framework binds too and the
+     * element resolver alone answers `undefined` for every one of them. It did,
+     * and the whole disc was then claimed inside the note. `null` is for an end
+     * bound to NOTHING: an unattached end is a free arrowhead in open canvas, and
+     * the whole disc around it is the author's target.
+     */
+    endGrabIncludesPoint(point: IVec): boolean;
     includesPoint(x: number, y: number, options?: PointTestOptions | undefined): boolean;
     labelIncludesPoint(point: IVec): boolean;
     moveTo(bound: Bound): void;
@@ -124,6 +202,16 @@ export declare class ConnectorElementModel extends GfxPrimitiveElementModel<Conn
      * Local control display and hide, mainly used in editing scenarios.
      */
     accessor labelEditing: boolean;
+    /**
+     * The end whose label is currently open in the DOM editor, if any — the
+     * end-label twin of `labelEditing`, and `@local()` for the same reason: it
+     * is a property of this client's editing session, not of the document.
+     *
+     * One selector rather than two booleans because only one label can be edited
+     * at a time, and because it is the same `'source' | 'target'` the editor's
+     * `which` argument carries.
+     */
+    accessor endLabelEditing: ConnectorLabelEnd | null;
     accessor mode: ConnectorMode;
     accessor path: PointLocation[];
     accessor rearEndpointStyle: PointStyle;
@@ -131,10 +219,57 @@ export declare class ConnectorElementModel extends GfxPrimitiveElementModel<Conn
     accessor rough: boolean | undefined;
     accessor roughness: number;
     accessor source: Connection;
+    /**
+     * The content of the label beside the SOURCE end — a multiplicity, a role
+     * name, a qualifier. `undefined` on every connector that has none, which is
+     * almost all of them.
+     *
+     * ### Why four flat fields and not two records
+     *
+     * A `Y.Text` nested inside a `Y.Map` inside the element's map would not be
+     * observed. The bridge that republishes a text edit as an element update is
+     * `watchText` in `syncElementFromY`
+     * (`packages/framework/std/src/gfx/model/surface/element-model.ts`): it walks
+     * the element's OWN `Y.Map`, and subscribes to every top-level value that is
+     * `instanceof Y.Text` — the centre `text` gets its observation from there and
+     * from nowhere else, which is why `text` carries no `@observe` decorator.
+     *
+     * Keeping the two end texts as top-level keys therefore buys the exact same
+     * observation, for free, on the exact same code path: type into an end label
+     * and the connector repaints, on this client and on every peer. A nested
+     * record would have needed an `@observe` bridge of its own, a second way of
+     * doing the one thing the centre label already does. ADR 0020.
+     *
+     * ### Absent by default
+     *
+     * `undefined` means the key is never written into the Y.Map at all (see the
+     * `@field()` `init`), so a connector that has no end label serialises
+     * byte-identically to one created before these fields existed: no migration,
+     * and an older build opens the document as a connector with two keys it does
+     * not read.
+     */
+    accessor sourceLabel: Y.Text | undefined;
+    /**
+     * The box of the source-end label, in the same absolute coordinates as
+     * `labelXYWH`. Absent until something places it — the pure default is
+     * `connectorEndLabelBox(path, 'source', size)`.
+     */
+    accessor sourceLabelXYWH: XYWH | undefined;
     accessor stroke: Color;
     accessor strokeStyle: StrokeStyle;
     accessor strokeWidth: number;
     accessor target: Connection;
+    /**
+     * The content of the label beside the TARGET end. See `sourceLabel` for why
+     * this is a flat `Y.Text` and what its absence guarantees.
+     */
+    accessor targetLabel: Y.Text | undefined;
+    /**
+     * The box of the target-end label, in the same absolute coordinates as
+     * `labelXYWH`. Absent until something places it — the pure default is
+     * `connectorEndLabelBox(path, 'target', size)`.
+     */
+    accessor targetLabelXYWH: XYWH | undefined;
     /**
      * The content of the label.
      */