@formicoidea/labre-core 0.31.0 → 0.33.0

package/dist/_pkgs/affine-inline-latex/command.js

@@ -1,7 +1,37 @@
 import { DocModeProvider, TelemetryProvider, } from '../affine-shared/services/index.js';
+function openInlineLatexEditor(inlineEditor, index) {
+    inlineEditor
+        .waitForUpdate()
+        .then(async () => {
+        await inlineEditor.waitForUpdate();
+        const textPoint = inlineEditor.getTextPoint(index);
+        if (!textPoint)
+            return;
+        const [text] = textPoint;
+        const latexNode = text.parentElement?.closest('affine-latex-node');
+        if (!latexNode)
+            return;
+        latexNode.toggleEditor();
+    })
+        .catch(console.error);
+}
+/**
+ * An inline equation can only replace a range living in a single block, so a
+ * selection spanning several blocks is refused instead of silently applying to
+ * its first block.
+ */
+function getSingleBlockInlineRange(textSelection) {
+    if (textSelection.to) {
+        return null;
+    }
+    return {
+        index: textSelection.from.index,
+        length: textSelection.from.length,
+    };
+}
 export const insertInlineLatex = (ctx, next) => {
     const textSelection = ctx.textSelection ?? ctx.currentTextSelection;
-    if (!textSelection || !textSelection.isCollapsed())
+    if (!textSelection)
         return;
     const blockComponent = ctx.std.view.getBlock(textSelection.from.blockId);
     if (!blockComponent)
@@ -12,18 +42,17 @@ export const insertInlineLatex = (ctx, next) => {
     const inlineEditor = richText.inlineEditor;
     if (!inlineEditor)
         return;
-    inlineEditor.insertText({
-        index: textSelection.from.index,
-        length: 0,
-    }, ' ');
-    inlineEditor.formatText({
-        index: textSelection.from.index,
-        length: 1,
-    }, {
-        latex: '',
-    });
+    const inlineRange = getSingleBlockInlineRange(textSelection);
+    if (!inlineRange)
+        return;
+    // A non-collapsed selection becomes the equation source, so selecting a
+    // formula and asking for an inline equation renders what was already typed.
+    const latex = textSelection.isCollapsed()
+        ? ''
+        : inlineEditor.yTextString.slice(inlineRange.index, inlineRange.index + inlineRange.length);
+    inlineEditor.insertText(inlineRange, ' ', { latex });
     inlineEditor.setInlineRange({
-        index: textSelection.from.index,
+        index: inlineRange.index,
         length: 1,
     });
     const mode = ctx.std.get(DocModeProvider).getEditorMode() ?? 'page';
@@ -39,19 +68,10 @@ export const insertInlineLatex = (ctx, next) => {
         module: 'inline equation',
         control: 'create inline equation',
     });
-    inlineEditor
-        .waitForUpdate()
-        .then(async () => {
-        await inlineEditor.waitForUpdate();
-        const textPoint = inlineEditor.getTextPoint(textSelection.from.index + 1);
-        if (!textPoint)
-            return;
-        const [text] = textPoint;
-        const latexNode = text.parentElement?.closest('affine-latex-node');
-        if (!latexNode)
-            return;
-        latexNode.toggleEditor();
-    })
-        .catch(console.error);
+    // Only an empty equation needs the editor right away; one built from a
+    // selection already has its content.
+    if (textSelection.isCollapsed()) {
+        openInlineLatexEditor(inlineEditor, inlineRange.index + 1);
+    }
     next();
 };

package/dist/_pkgs/affine-inline-latex/latex-node/latex-node.d.ts

@@ -2,15 +2,25 @@ import type { AffineTextAttributes } from '../../affine-shared/types/index.js';
 import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
 import { type InlineEditor } from '../../std/inline/index.js';
 import type { DeltaInsert } from '../../store/index.js';
+import { type PropertyValues } from 'lit';
 declare const AffineLatexNode_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
 export declare class AffineLatexNode extends AffineLatexNode_base {
     static styles: import("lit").CSSResult;
     private _editorAbortController;
+    private _isEditorOpen;
     readonly latex$: import("@preact/signals-core").Signal<string>;
     readonly latexEditorSignal: import("@preact/signals-core").Signal<string>;
     get deltaLatex(): string;
     get latexContainer(): HTMLElement | null;
     connectedCallback(): void;
+    /**
+     * The delta is the source of truth: when it changes underneath us (undo, a
+     * remote edit, a paste replacing the node) the signals must follow it,
+     * otherwise the node keeps painting the equation it was first created with.
+     * While the editor is open the user is the source of truth instead, so the
+     * in-flight draft is left alone.
+     */
+    protected updated(changedProperties: PropertyValues<this>): void;
     render(): import("lit-html").TemplateResult<1>;
     toggleEditor(): void;
     get readonly(): boolean;

package/dist/_pkgs/affine-inline-latex/latex-node/latex-node.js

@@ -203,6 +203,26 @@ let AffineLatexNode = (() => {
             });
             return result;
         }
+        /**
+         * The delta is the source of truth: when it changes underneath us (undo, a
+         * remote edit, a paste replacing the node) the signals must follow it,
+         * otherwise the node keeps painting the equation it was first created with.
+         * While the editor is open the user is the source of truth instead, so the
+         * in-flight draft is left alone.
+         */
+        updated(changedProperties) {
+            super.updated(changedProperties);
+            if (!changedProperties.has('delta') || this._isEditorOpen) {
+                return;
+            }
+            const latex = this.deltaLatex;
+            if (this.latex$.peek() !== latex) {
+                this.latex$.value = latex;
+            }
+            if (this.latexEditorSignal.peek() !== latex) {
+                this.latexEditorSignal.value = latex;
+            }
+        }
         render() {
             return html `<span class="affine-latex" data-selected=${this.selected}
       ><div class="latex-container"></div>
@@ -237,7 +257,9 @@ let AffineLatexNode = (() => {
                     zIndex: 'var(--affine-z-index-popover)',
                 },
             });
+            this._isEditorOpen = true;
             this._editorAbortController.signal.addEventListener('abort', () => {
+                this._isEditorOpen = false;
                 portal.remove();
                 const latex = this.latexEditorSignal.peek();
                 this.latex$.value = latex;
@@ -279,6 +301,7 @@ let AffineLatexNode = (() => {
         constructor() {
             super(...arguments);
             this._editorAbortController = null;
+            this._isEditorOpen = false;
             this.latex$ = signal('');
             this.latexEditorSignal = signal('');
             this.#delta_accessor_storage = __runInitializers(this, _delta_initializers, {

package/dist/_pkgs/affine-inline-link/command.js

@@ -1,4 +1,4 @@
-import { INLINE_ROOT_ATTR, } from '../std/inline/index.js';
+import { INLINE_ROOT_ATTR } from '../std/inline/index.js';
 import { toggleLinkPopup } from './link-node/link-popup/toggle-link-popup.js';
 export const toggleLink = (ctx, next) => {
     const selection = document.getSelection();

package/dist/_pkgs/affine-inline-link/link-node/affine-link.js

@@ -124,10 +124,13 @@ let AffineLink = (() => {
     ></a>`;
         }
         render() {
+            // No `text-decoration` here on purpose: this object is the OVERRIDE handed
+            // to `affineTextStyles`, and it is spread last, so any decoration it names
+            // would silently erase the one computed from `strike` / `underline`.
+            // A plain link still shows none — `affineTextStyles` defaults to 'none'.
             const linkStyle = {
                 color: 'var(--affine-link-color)',
                 fill: 'var(--affine-link-color)',
-                'text-decoration': 'none',
                 cursor: 'pointer',
             };
             if (this.delta.attributes && this.delta.attributes?.code) {

package/dist/_pkgs/affine-inline-preset/adapters/html/html-inline.d.ts

@@ -1,6 +1,9 @@
 export declare const htmlTextToDeltaMatcher: import("../../../store/index.js").ExtensionType & {
     identifier: import("../../../global/di/types.js").ServiceIdentifier<import("../../../affine-shared/adapters/index.js").HtmlASTToDeltaMatcher>;
 };
+export declare const htmlColorStyleElementToDeltaMatcher: import("../../../store/index.js").ExtensionType & {
+    identifier: import("../../../global/di/types.js").ServiceIdentifier<import("../../../affine-shared/adapters/index.js").HtmlASTToDeltaMatcher>;
+};
 export declare const htmlTextLikeElementToDeltaMatcher: import("../../../store/index.js").ExtensionType & {
     identifier: import("../../../global/di/types.js").ServiceIdentifier<import("../../../affine-shared/adapters/index.js").HtmlASTToDeltaMatcher>;
 };

package/dist/_pkgs/affine-inline-preset/adapters/html/html-inline.js

@@ -1,4 +1,4 @@
-import { HtmlASTToDeltaExtension, } from '../../../affine-shared/adapters/index.js';
+import { extractColorFromStyle, HtmlASTToDeltaExtension, resolveNearestSupportedColor, } from '../../../affine-shared/adapters/index.js';
 import { collapseWhiteSpace } from 'collapse-white-space';
 /**
  * Handle empty text nodes created by HTML parser for styling purposes.
@@ -147,6 +147,33 @@ export const htmlTextToDeltaMatcher = HtmlASTToDeltaExtension({
         return value ? [{ insert: value }] : [];
     },
 });
+export const htmlColorStyleElementToDeltaMatcher = HtmlASTToDeltaExtension({
+    name: 'color-style-element',
+    match: ast => isElement(ast) &&
+        ast.tagName === 'span' &&
+        typeof ast.properties?.style === 'string' &&
+        /color\s*:/i.test(ast.properties.style),
+    toDelta: (ast, context) => {
+        if (!isElement(ast)) {
+            return [];
+        }
+        const baseOptions = { ...context.options, trim: false };
+        // In preformatted contexts (e.g. code blocks) we don't keep inline colors.
+        if (baseOptions.pre) {
+            return ast.children.flatMap(child => context.toDelta(child, baseOptions));
+        }
+        const colorValue = extractColorFromStyle(typeof ast.properties?.style === 'string' ? ast.properties.style : '');
+        const mappedColor = colorValue
+            ? resolveNearestSupportedColor(colorValue)
+            : null;
+        return ast.children.flatMap(child => context.toDelta(child, baseOptions).map(delta => {
+            if (mappedColor) {
+                delta.attributes = { ...delta.attributes, color: mappedColor };
+            }
+            return delta;
+        }));
+    },
+});
 export const htmlTextLikeElementToDeltaMatcher = HtmlASTToDeltaExtension({
     name: 'text-like-element',
     match: ast => isTextLikeElement(ast),
@@ -251,6 +278,7 @@ export const htmlBrElementToDeltaMatcher = HtmlASTToDeltaExtension({
 });
 export const HtmlInlineToDeltaAdapterExtensions = [
     htmlTextToDeltaMatcher,
+    htmlColorStyleElementToDeltaMatcher,
     htmlTextLikeElementToDeltaMatcher,
     htmlStrongElementToDeltaMatcher,
     htmlItalicElementToDeltaMatcher,

package/dist/_pkgs/affine-inline-preset/command/format-block.js

@@ -1,5 +1,5 @@
 import { getSelectedBlocksCommand } from '../../affine-shared/commands/index.js';
-import { INLINE_ROOT_ATTR, } from '../../std/inline/index.js';
+import { INLINE_ROOT_ATTR } from '../../std/inline/index.js';
 import { FORMAT_BLOCK_SUPPORT_FLAVOURS } from './consts.js';
 // for block selection
 export const formatBlockCommand = (ctx, next) => {

package/dist/_pkgs/affine-inline-preset/command/format-native.js

@@ -1,5 +1,5 @@
-import { BLOCK_ID_ATTR, } from '../../std/index.js';
-import { INLINE_ROOT_ATTR, } from '../../std/inline/index.js';
+import { BLOCK_ID_ATTR } from '../../std/index.js';
+import { INLINE_ROOT_ATTR } from '../../std/inline/index.js';
 import { FORMAT_NATIVE_SUPPORT_FLAVOURS } from './consts.js';
 // for native range
 export const formatNativeCommand = (ctx, next) => {

package/dist/_pkgs/affine-inline-preset/command/format-text.js

@@ -1,6 +1,6 @@
 import { clearMarksOnDiscontinuousInput } from '../../affine-rich-text/index.js';
 import { getSelectedBlocksCommand } from '../../affine-shared/commands/index.js';
-import { INLINE_ROOT_ATTR, } from '../../std/inline/index.js';
+import { INLINE_ROOT_ATTR } from '../../std/inline/index.js';
 import { FORMAT_TEXT_SUPPORT_FLAVOURS } from './consts.js';
 // for text selection
 export const formatTextCommand = (ctx, next) => {

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

@@ -1,4 +1,4 @@
-import { InlineSpecExtension, } from '../std/inline/index.js';
+import { InlineSpecExtension } from '../std/inline/index.js';
 import { html } from 'lit';
 import { z } from 'zod';
 export const BoldInlineSpecExtension = InlineSpecExtension({

package/dist/_pkgs/affine-inline-reference/reference-node/reference-node.js

@@ -34,7 +34,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 };
 import { whenHover } from '../../affine-components/hover/index.js';
 import { Peekable } from '../../affine-components/peek/index.js';
-import { DEFAULT_DOC_NAME, REFERENCE_NODE, } from '../../affine-shared/consts/index.js';
+import { DEFAULT_DOC_NAME, REFERENCE_NODE } from '../../affine-shared/consts/index.js';
 import { DocDisplayMetaProvider, ToolbarRegistryIdentifier, } from '../../affine-shared/services/index.js';
 import { affineTextStyles } from '../../affine-shared/styles/index.js';
 import { cloneReferenceInfo, referenceToNode, } from '../../affine-shared/utils/index.js';

package/dist/_pkgs/affine-model/blocks/code/code-model.d.ts

@@ -7,6 +7,7 @@ type CodeBlockProps = {
     caption: string;
     preview?: boolean;
     lineNumber?: boolean;
+    collapsed?: boolean;
     comments?: Record<string, boolean>;
 } & BlockMeta;
 export declare const CodeBlockSchema: {

package/dist/_pkgs/affine-model/blocks/code/code-model.js

@@ -8,6 +8,7 @@ export const CodeBlockSchema = defineBlockSchema({
         caption: '',
         preview: undefined,
         lineNumber: undefined,
+        collapsed: undefined,
         comments: undefined,
         'meta:createdAt': undefined,
         'meta:createdBy': undefined,

package/dist/_pkgs/affine-model/elements/bpmn/node.d.ts

@@ -1,17 +1,50 @@
 import { ShapeElementModel } from '../shape/index.js';
 /**
- * The BPMN flow-object nodes shipped in v1. Each maps onto a native shape:
- *  - `startEvent` / `endEvent` → an ellipse (thin green / thick red ring)
- *  - `task`                    → a rounded rectangle with editable inner text
- *  - `gatewayExclusive`        → a diamond decorated with an X glyph
+ * The BPMN artefacts the pack draws — the **descriptive conformance subclass**
+ * of BPMN 2.0. Each maps onto a native shape, decorated by a glyph where the
+ * notation asks for one:
+ *
+ *  - events (ellipse)   — `startEvent` / `endEvent` plain, plus the message and
+ *    timer starts and the message and terminate ends;
+ *  - activities (rect)  — `task` plain, plus the user and service tasks, the
+ *    collapsed sub-process and the call activity;
+ *  - gateways (diamond) — `gatewayExclusive` (X) and `gatewayParallel` (+);
+ *  - data & artifacts   — `dataObject`, `dataStore` and `textAnnotation`, whose
+ *    silhouettes (folded page, cylinder, open bracket) are drawn by the glyph
+ *    over a native rect with its own stroke and fill turned off;
+ *  - `group`            — a dashed rounded rectangle drawn AROUND things.
+ *
+ * `group` is the odd one and deliberately so. Every other kind is a node the
+ * process is made of; a group is a lasso somebody drew round part of it. The
+ * spec (BPMN 2.0.2 §10.4) exempts it from every connection and containment
+ * constraint there is — it cannot be attached to a sequence or message flow, it
+ * is not bounded by the pool or lane it overlaps, and it may straddle several
+ * pools at once. Nothing here has to enforce that, because a group is unfilled:
+ * it is hit near its border and on its label, so it never steals a click from
+ * what it encloses, and what it encloses never becomes its content.
+ *
+ * ## Compatibility
+ *
+ * This union is only ever WIDENED, and it is widened with new VALUES of the
+ * existing `kind` string field — no new field, no schema change, no migration
+ * and no backfill. The precedent is `wardley`'s (`gfx/wardley/src/roles.ts`):
+ * a process drawn before today carries one of the four original values, loads
+ * unchanged and paints exactly as it always did.
+ *
+ * The expanded (drilled-in) sub-process is deliberately NOT here: `subProcess`
+ * is the COLLAPSED representation only — a task-sized rectangle with the `+`
+ * marker. An expanded sub-process is a container with its own flow inside it,
+ * which is a containment model this pack does not have yet.
  */
-export type BpmnNodeKind = 'startEvent' | 'endEvent' | 'task' | 'gatewayExclusive';
+export type BpmnNodeKind = 'startEvent' | 'startEventMessage' | 'startEventTimer' | 'endEvent' | 'endEventMessage' | 'endEventTerminate' | 'task' | 'taskUser' | 'taskService' | 'subProcess' | 'callActivity' | 'gatewayExclusive' | 'gatewayParallel' | 'dataObject' | 'dataStore' | 'textAnnotation' | 'group';
 /**
  * A BPMN flow-object node. Extends {@link ShapeElementModel} (a native shape)
  * so it inherits ALL shape behaviour — editable stroke width / colors, inner
  * text, native resize, the shape context toolbar — for free. `kind`
- * discriminates the four basics; only `gatewayExclusive` is decorated with a
- * glyph (the X) by the renderer (the others are plain native shapes).
+ * discriminates the artefacts and drives the RENDERING alone; what a node
+ * MEANS is the `role` stamped on it at creation (`gfx/bpmn/src/roles.ts`).
+ * The plain start event, end event and task are undecorated native shapes;
+ * every other kind is decorated with a glyph by the renderer.
  *
  * Mirrors {@link EdgyNodeElementModel}.
  */

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

@@ -38,8 +38,10 @@ import { ShapeElementModel } from '../shape/index.js';
  * A BPMN flow-object node. Extends {@link ShapeElementModel} (a native shape)
  * so it inherits ALL shape behaviour — editable stroke width / colors, inner
  * text, native resize, the shape context toolbar — for free. `kind`
- * discriminates the four basics; only `gatewayExclusive` is decorated with a
- * glyph (the X) by the renderer (the others are plain native shapes).
+ * discriminates the artefacts and drives the RENDERING alone; what a node
+ * MEANS is the `role` stamped on it at creation (`gfx/bpmn/src/roles.ts`).
+ * The plain start event, end event and task are undecorated native shapes;
+ * every other kind is decorated with a glyph by the renderer.
  *
  * Mirrors {@link EdgyNodeElementModel}.
  */

package/dist/_pkgs/affine-model/elements/bpmn/pool.d.ts

@@ -1,30 +1,87 @@
-import type { IVec, SerializedXYWH } from '../../../global/gfx/index.js';
-import { Bound } from '../../../global/gfx/index.js';
-import type { BaseElementProps } from '../../../std/gfx/index.js';
-import { GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
-export type BpmnPoolProps = BaseElementProps & {
+import type { SerializedXYWH } from '../../../global/gfx/index.js';
+import type { FrameworkBackgroundProps } from '../framework-background/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
+/**
+ * One LANE (couloir) of a pool: a horizontal band the participant's own work is
+ * divided into — "Sales", "Back office", "Automated".
+ *
+ * The shape of a {@link BackgroundInstanceZoneItem} in
+ * `@labre/affine-block-surface`, and deliberately the same three fields: the
+ * primitive paints an instance partition from that structure, the audit reports
+ * it from that structure, and a lane that had a shape of its own would be a
+ * fourth place the two have to agree.
+ *
+ * `size` is a relative WEIGHT, not a height in model units: lanes share the
+ * plot in proportion to their sizes, so a pool dragged taller redistributes the
+ * extra space instead of leaving a gap under the last band. `2` reads as "twice
+ * the other one", which is the only thing a lane's height ever means.
+ */
+export interface BpmnLane {
+    /** Stable id, generated at creation. Never the name: a lane can be renamed. */
+    id: string;
+    /** The lane name, written horizontally in its top-left corner. */
+    name?: string;
+    /** Relative weight — see above. Must be a finite number greater than zero. */
+    size: number;
+}
+export type BpmnPoolProps = FrameworkBackgroundProps & {
     /** The participant name shown in the left band — edited inline on dblclick. */
     name?: string;
-    /** When false the resize handles are hidden — toggled from the toolbar. */
-    resizeEnabled?: boolean;
+    /** The pool's own partition into lanes. Absent until the first one is added. */
+    lanes?: BpmnLane[];
 };
 /**
  * A BPMN "pool": a participant container drawn as a rounded-rect frame with a
- * vertical name band on the left. It is a background element (like the wardley
- * / cynefin backgrounds): the user drops flow-object nodes on top of it. Lanes
- * are deliberately out of scope for v1.
+ * vertical name band on the left. It is a framework background like every other
+ * one in the library — the user drops flow-object nodes on top of it, and a
+ * connector never snaps to it.
+ *
+ * The geometry of a passive canvas comes from
+ * {@link FrameworkBackgroundElementModel}: this class used to restate all five
+ * of those overrides verbatim, which is exactly the kind of copy that drifts.
+ * The persisted type is still `bpmnPool`, and the first four fields below are
+ * the four it has always written, in the same order, with the same defaults.
  *
- * Mirrors the other framework background elements.
+ * What it LOOKS like is declared, not coded: see `BPMN_POOL_BACKGROUND` in
+ * `@labre/affine-gfx-bpmn`.
  */
-export declare class BpmnPoolElementModel extends GfxPrimitiveElementModel<BpmnPoolProps> {
+export declare class BpmnPoolElementModel extends FrameworkBackgroundElementModel<BpmnPoolProps> {
     get type(): string;
-    get connectable(): boolean;
-    containsBound(bounds: Bound): boolean;
-    getLineIntersections(start: IVec, end: IVec): import("../../../global/gfx/index.js").PointLocation[] | null;
-    getNearestPoint(point: IVec): IVec;
-    includesPoint(x: number, y: number): boolean;
     accessor name: string;
     accessor resizeEnabled: boolean;
     accessor rotate: number;
     accessor xywh: SerializedXYWH;
+    /**
+     * The pool's own partition into lanes, in top-to-bottom order.
+     *
+     * The FIFTH field, and the only one that is optional. It mirrors
+     * `validationExceptions` on the base element model exactly, for the same three
+     * reasons:
+     *
+     * - **`undefined`, not `[]`.** `@field()`'s `init` writes nothing for an
+     *   `undefined` default, so a pool that has no lane stays byte-identical to
+     *   one created before this field existed: optional field, no schema version
+     *   bump, no migration, and every document already on disk opens and paints
+     *   exactly as it did (pinned by `pool-background.unit.spec.ts`, whose
+     *   fixture carries no `lanes` key). Removing the last lane goes back through
+     *   `clearField`, which deletes the KEY rather than leaving a phantom one.
+     * - **Flat JSON on purpose.** Element serialization is one level deep, and a
+     *   value a Yjs update can encode is the contract `_assignElementProp`
+     *   enforces. A nested `Y.Map` is what `tags` needs and this does not (see
+     *   `docs/adr/0007`): a lane list is one atomic choice about how a single
+     *   participant's own band is cut, authored by whoever is drawing the
+     *   process — not an accumulating multi-key set different people qualify
+     *   concurrently. The trade is stated so it is reviewed, not discovered:
+     *   two peers reordering the lanes at the same moment resolve
+     *   last-write-wins, one whole list winning over the other.
+     * - **Declared HERE and not on the base class.** A lane is a subdivision of a
+     *   pool and of nothing else, and the accessor is what carries the value
+     *   through a copy, a paste or a template insertion, so a duplicated pool
+     *   arrives with its lanes.
+     *
+     * What it MEANS is declared, not coded: `BPMN_POOL_BACKGROUND.instanceZones`
+     * in `@labre/affine-gfx-bpmn` names this prop, and the framework-background
+     * primitive paints the dividers and the names from it.
+     */
+    accessor lanes: BpmnLane[] | undefined;
 }

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

@@ -32,18 +32,25 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { Bound, getPointsFromBoundWithRotation, linePolygonIntersects, pointInPolygon, polygonNearestPoint, } from '../../../global/gfx/index.js';
-import { field, GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { field } from '../../../std/gfx/index.js';
+import { FrameworkBackgroundElementModel } from '../framework-background/index.js';
 /**
  * A BPMN "pool": a participant container drawn as a rounded-rect frame with a
- * vertical name band on the left. It is a background element (like the wardley
- * / cynefin backgrounds): the user drops flow-object nodes on top of it. Lanes
- * are deliberately out of scope for v1.
+ * vertical name band on the left. It is a framework background like every other
+ * one in the library — the user drops flow-object nodes on top of it, and a
+ * connector never snaps to it.
  *
- * Mirrors the other framework background elements.
+ * The geometry of a passive canvas comes from
+ * {@link FrameworkBackgroundElementModel}: this class used to restate all five
+ * of those overrides verbatim, which is exactly the kind of copy that drifts.
+ * The persisted type is still `bpmnPool`, and the first four fields below are
+ * the four it has always written, in the same order, with the same defaults.
+ *
+ * What it LOOKS like is declared, not coded: see `BPMN_POOL_BACKGROUND` in
+ * `@labre/affine-gfx-bpmn`.
  */
 let BpmnPoolElementModel = (() => {
-    let _classSuper = GfxPrimitiveElementModel;
+    let _classSuper = FrameworkBackgroundElementModel;
     let _name_decorators;
     let _name_initializers = [];
     let _name_extraInitializers = [];
@@ -56,6 +63,9 @@ let BpmnPoolElementModel = (() => {
     let _xywh_decorators;
     let _xywh_initializers = [];
     let _xywh_extraInitializers = [];
+    let _lanes_decorators;
+    let _lanes_initializers = [];
+    let _lanes_extraInitializers = [];
     return class BpmnPoolElementModel extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -63,33 +73,17 @@ let BpmnPoolElementModel = (() => {
             _resizeEnabled_decorators = [field(true)];
             _rotate_decorators = [field(0)];
             _xywh_decorators = [field()];
+            _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);
             __esDecorate(this, null, _rotate_decorators, { kind: "accessor", name: "rotate", static: false, private: false, access: { has: obj => "rotate" in obj, get: obj => obj.rotate, set: (obj, value) => { obj.rotate = value; } }, metadata: _metadata }, _rotate_initializers, _rotate_extraInitializers);
             __esDecorate(this, null, _xywh_decorators, { kind: "accessor", name: "xywh", static: false, private: false, access: { has: obj => "xywh" in obj, get: obj => obj.xywh, set: (obj, value) => { obj.xywh = value; } }, metadata: _metadata }, _xywh_initializers, _xywh_extraInitializers);
+            __esDecorate(this, null, _lanes_decorators, { kind: "accessor", name: "lanes", static: false, private: false, access: { has: obj => "lanes" in obj, get: obj => obj.lanes, set: (obj, value) => { obj.lanes = value; } }, metadata: _metadata }, _lanes_initializers, _lanes_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         get type() {
             return 'bpmnPool';
         }
-        get connectable() {
-            return false;
-        }
-        containsBound(bounds) {
-            const points = getPointsFromBoundWithRotation(this);
-            return points.some(point => bounds.containsPoint(point));
-        }
-        getLineIntersections(start, end) {
-            const points = getPointsFromBoundWithRotation(this);
-            return linePolygonIntersects(start, end, points);
-        }
-        getNearestPoint(point) {
-            return polygonNearestPoint(Bound.deserialize(this.xywh).points, point);
-        }
-        includesPoint(x, y) {
-            const points = getPointsFromBoundWithRotation(this);
-            return pointInPolygon([x, y], points);
-        }
         #name_accessor_storage = __runInitializers(this, _name_initializers, 'Pool');
         get name() { return this.#name_accessor_storage; }
         set name(value) { this.#name_accessor_storage = value; }
@@ -102,9 +96,44 @@ let BpmnPoolElementModel = (() => {
         #xywh_accessor_storage = (__runInitializers(this, _rotate_extraInitializers), __runInitializers(this, _xywh_initializers, '[0,0,560,200]'));
         get xywh() { return this.#xywh_accessor_storage; }
         set xywh(value) { this.#xywh_accessor_storage = value; }
+        #lanes_accessor_storage = (__runInitializers(this, _xywh_extraInitializers), __runInitializers(this, _lanes_initializers, undefined));
+        /**
+         * The pool's own partition into lanes, in top-to-bottom order.
+         *
+         * The FIFTH field, and the only one that is optional. It mirrors
+         * `validationExceptions` on the base element model exactly, for the same three
+         * reasons:
+         *
+         * - **`undefined`, not `[]`.** `@field()`'s `init` writes nothing for an
+         *   `undefined` default, so a pool that has no lane stays byte-identical to
+         *   one created before this field existed: optional field, no schema version
+         *   bump, no migration, and every document already on disk opens and paints
+         *   exactly as it did (pinned by `pool-background.unit.spec.ts`, whose
+         *   fixture carries no `lanes` key). Removing the last lane goes back through
+         *   `clearField`, which deletes the KEY rather than leaving a phantom one.
+         * - **Flat JSON on purpose.** Element serialization is one level deep, and a
+         *   value a Yjs update can encode is the contract `_assignElementProp`
+         *   enforces. A nested `Y.Map` is what `tags` needs and this does not (see
+         *   `docs/adr/0007`): a lane list is one atomic choice about how a single
+         *   participant's own band is cut, authored by whoever is drawing the
+         *   process — not an accumulating multi-key set different people qualify
+         *   concurrently. The trade is stated so it is reviewed, not discovered:
+         *   two peers reordering the lanes at the same moment resolve
+         *   last-write-wins, one whole list winning over the other.
+         * - **Declared HERE and not on the base class.** A lane is a subdivision of a
+         *   pool and of nothing else, and the accessor is what carries the value
+         *   through a copy, a paste or a template insertion, so a duplicated pool
+         *   arrives with its lanes.
+         *
+         * What it MEANS is declared, not coded: `BPMN_POOL_BACKGROUND.instanceZones`
+         * in `@labre/affine-gfx-bpmn` names this prop, and the framework-background
+         * primitive paints the dividers and the names from it.
+         */
+        get lanes() { return this.#lanes_accessor_storage; }
+        set lanes(value) { this.#lanes_accessor_storage = value; }
         constructor() {
             super(...arguments);
-            __runInitializers(this, _xywh_extraInitializers);
+            __runInitializers(this, _lanes_extraInitializers);
         }
     };
 })();