@unofficialbox/box-open-elements 0.31.2 → 0.33.0

package/dist/patterns/process-modeler/model.d.ts

@@ -31,6 +31,12 @@ export interface ProcessBox<N = unknown> {
     /** Show the loop mark in a repeating frame without inferring host semantics from its kind name. */
     loopMark?: boolean;
     parentId?: string;
+    /** Present (including []) when this host supports variables local to this step/frame. */
+    localVariables?: readonly ProcessLocalVariable[];
+    /** Explicit opt-in to host-owned local edit requests; absent collections are readonly. */
+    localVariablesEditable?: boolean;
+    /** Host-owned saved output name, displayed in the variable usage summary. */
+    savedResult?: string;
 }
 export interface ProcessLine {
     id: string;
@@ -63,6 +69,29 @@ export interface ProcessVariable {
     startingValue?: string;
     problem?: string;
 }
+export interface ProcessLocalVariable {
+    name: string;
+    startingValue?: string;
+    /** Plain-text host validation; BOE does not evaluate expressions. */
+    problem?: string;
+}
+export type ProcessLocalVariableEdit = {
+    type: 'add';
+} | {
+    type: 'remove';
+    index: number;
+    name: string;
+} | {
+    type: 'rename' | 'starting-value';
+    index: number;
+    name: string;
+    value: string;
+};
+export interface ProcessLocalVariableEditRequest {
+    boxId: string;
+    path?: NodePath;
+    edit: ProcessLocalVariableEdit;
+}
 /** Host-owned variable edits; the host echoes the updated variables property. */
 export type ProcessVariableEdit = {
     type: 'add';
@@ -73,6 +102,10 @@ export type ProcessVariableEdit = {
     type: 'rename';
     name: string;
     value: string;
+} | {
+    type: 'description';
+    name: string;
+    value: string;
 } | {
     type: 'scope';
     name: string;
@@ -141,8 +174,21 @@ export interface ProcessLastRun {
     /** Keys are projected box IDs, supplied by the host. */
     steps: Readonly<Record<string, ProcessStepMetrics>>;
 }
+/** A proposed host-owned connection, also used when reattaching a line. */
+export interface ProcessConnectionProposal {
+    readonly from: string;
+    readonly to: string;
+    /** Exclude this existing line from duplicate/outgoing-limit checks. */
+    readonly ignoreLineId?: string;
+}
 export interface ProcessModel<D = unknown, N = unknown> {
     project(document: D): ProcessProjection<N>;
+    /** Pure synchronous host rule: a nonempty reason rejects preview and commit.
+     * Returning null permits an edit request; the host must still accept it. */
+    connectionProblem?(document: D, proposal: ProcessConnectionProposal, projection: ProcessProjection<N>): string | null;
+    /** Optional synchronous host transaction for Tidy/section semantics.
+     * A capable host accepts or refuses; BOE does not fall back to local edits. */
+    layoutEdit?(document: D, request: ProcessLayoutEditRequest, projection: ProcessProjection<N>): void;
     /** Optional host arrangement, used by Tidy up and for missing positions. */
     arrange?(projection: ProcessProjection<N>): ProcessLayout;
     /**
@@ -187,15 +233,58 @@ export interface ProcessCheck {
     boxId?: string;
     path?: NodePath;
 }
+/** Insertion intent; explicit centers use canvas world coordinates, not top-left positions. */
+export type ProcessInsertionPlacement = {
+    readonly source: 'direction';
+    readonly side: ProcessSide;
+} | {
+    readonly source: 'next';
+} | {
+    readonly source: 'line';
+    readonly center: Readonly<{
+        x: number;
+        y: number;
+    }>;
+} | {
+    readonly source: 'point';
+    readonly center: Readonly<{
+        x: number;
+        y: number;
+    }>;
+};
+/** IDs are scoped by kind; layout notes are separate from projected boxes. */
+export type ProcessSelectionItem = {
+    readonly type: 'box';
+    readonly id: string;
+} | {
+    readonly type: 'line';
+    readonly id: string;
+} | {
+    readonly type: 'note';
+    readonly id: string;
+};
 export interface ProcessEdit {
-    type: "add" | "delete" | "duplicate" | "connect" | "disconnect" | "reattach" | "insert" | "reparent";
+    type: "add" | "delete" | "duplicate" | "connect" | "disconnect" | "reattach" | "insert" | "reparent" | "reset-line" | "tidy" | "make-section" | "delete-selection";
+    /** One atomic mixed deletion; the host owns protected roots, descendants,
+     * incident edges and notes. Unsupported hosts must leave it unapplied. */
+    selection?: readonly ProcessSelectionItem[];
     boxId?: string;
     sourceId?: string;
+    /** Duplicate these roots and descendants/internal edges in one host transaction.
+     * Plural requests omit sourceId; unsupported hosts must refuse the whole group. */
+    sourceIds?: readonly string[];
+    /** One world-coordinate translation for every node in a duplicate group. */
+    offset?: Readonly<{
+        x: number;
+        y: number;
+    }>;
     from?: string;
     to?: string;
     lineId?: string;
     kind?: FlowKind;
     position?: BoxPosition;
+    /** Optional for existing hosts; all built-in insertion producers supply intent. */
+    placement?: ProcessInsertionPlacement;
     parentId?: string;
     fromSide?: ProcessSide;
     toSide?: ProcessSide;
@@ -208,11 +297,53 @@ export interface ReversibleProcessEdit {
     redo(): void;
     /** The already-applied edit's layout, recorded atomically with the document. */
     layout?: ProcessLayout;
+    /** Selection after acceptance; recorded with layout for undo and redo. */
+    selectionIds?: readonly string[];
+    /** Full mixed selection after acceptance; takes precedence over selectionIds. */
+    selection?: readonly ProcessSelectionItem[];
 }
 /** Host applies the edit, then calls accept with its inverse and replay. */
 export interface ProcessEditRequest extends ProcessEdit {
     accept(command: ReversibleProcessEdit): void;
 }
+/** Host-owned document/layout operation. Null sourceIds means whole-process Tidy.
+ * The host owns eligibility, section membership, route cleanup and related notes. */
+export interface ProcessLayoutEditRequest {
+    readonly type: 'tidy' | 'make-section';
+    readonly sourceIds: readonly string[] | null;
+    readonly title?: string;
+    /** Detached current layout; a host may use it to preserve unrelated data. */
+    readonly layout: ProcessLayout;
+    /** Host has already applied the document edit; full layout is required. */
+    accept(command: ReversibleProcessEdit & {
+        layout: ProcessLayout;
+    }): void;
+    refuse(message?: string): void;
+}
+/** Host-owned immutable capture; BOE never serializes the captured graph. */
+export interface ProcessClipboard {
+    readonly itemCount: number;
+    paste(request: ProcessPasteRequest): void;
+    dispose?(): void;
+}
+/** Copy capture is synchronous and once-only. Unsupported hosts leave it unhandled. */
+export interface ProcessCopyRequest {
+    /** Full immutable selection, including notes and explicit edges. Hosts own
+     * descendant/internal-edge capture and must refuse unsupported mixed capture. */
+    readonly selection?: readonly ProcessSelectionItem[];
+    readonly sourceIds: readonly string[];
+    capture(clipboard: ProcessClipboard): void;
+    refuse(message?: string): void;
+}
+/** Host applies one synchronous graph transaction, then accepts it once. */
+export interface ProcessPasteRequest {
+    readonly offset: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    accept(command: ReversibleProcessEdit): void;
+    refuse(message?: string): void;
+}
 export declare function validateProjection<N>(projection: ProcessProjection<N>): void;
 /** Deterministic fallback, preserving host-authored positions. */
 export declare function completeLayout<N>(projection: ProcessProjection<N>, layout: ProcessLayout): ProcessLayout;

package/dist/patterns/process-modeler/process-modeler.d.ts

@@ -1,7 +1,44 @@
 import { BaseElement } from "../../core/index.js";
 import type { NodePath } from "../flow-builder/model.js";
 import type { ProcessConnection, ProcessVariable, ProcessLoadOptions, ProcessKind, ProcessLastRun, ProcessOutlineItem, ProcessField } from "./model.js";
-import { ProcessHistory, type ProcessBox, type ProcessCheck, type ProcessEdit, type ProcessLayout, type ProcessModel, type ProcessProjection } from "./model.js";
+import { ProcessHistory, type ProcessBox, type ProcessCheck, type ProcessEdit, type ProcessSelectionItem, type ProcessCopyRequest, type ProcessLayout, type ProcessModel, type ProcessProjection } from "./model.js";
+/** Source-owned contracts for notifications forwarded through the acceptance queue. */
+export interface ProcessModelerEventDetails {
+    'note-move-request': {
+        noteIds: readonly string[];
+        notes: readonly NonNullable<ProcessLayout['notes']>[number][];
+    };
+    'process-copy-request': ProcessCopyRequest;
+    'process-selection-copy-request': ProcessCopyRequest;
+    'layout-changed': {
+        layout: ProcessLayout;
+    };
+    'positions-changed': {
+        positions: readonly import('./model.js').ProcessPositionSnapshot[];
+        version: string | number;
+    };
+    'projection-changed': {
+        projection: ProcessProjection;
+        version: string | number;
+        checks: readonly ProcessCheck[];
+    };
+    'readable-projection-changed': {
+        projection: ProcessProjection;
+        version: string | number;
+    };
+    'selection-changed': {
+        selection?: readonly ProcessSelectionItem[];
+        box: ProcessBox | null;
+        boxes: readonly ProcessBox[];
+        path: NodePath | null;
+    } | {
+        selection?: readonly ProcessSelectionItem[];
+        box: null;
+        boxes: never[];
+        line: import('./model.js').ProcessLine | null;
+        path: null;
+    };
+}
 /** Projects host documents without owning workflow schemas or persistence. */
 export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends BaseElement {
     static readonly tagName = "box-process-modeler";
@@ -16,6 +53,9 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private showLastRunValue;
     private selectedId;
     private selectedLineId;
+    private selectedLineIds;
+    private selectedNoteIds;
+    private graphSelection;
     private connecting;
     private checks;
     private renderer?;
@@ -23,6 +63,8 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private inspected?;
     private inspectedId?;
     private inspectedControls;
+    private localEchoRevision;
+    private pendingLocalRename?;
     private historyValue;
     private viewport;
     private pointers;
@@ -37,7 +79,14 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private activeDrawer?;
     private drawerReturn?;
     private selectedIds;
-    private clipboardIds;
+    private clipboard;
+    private clipboardSession;
+    private layoutEditSession;
+    private acceptanceNotifications;
+    private deferredNotifications;
+    private notify;
+    private flushAcceptanceNotifications;
+    private restoringBoxFocus;
     private selectionToolbarKey;
     private sectionSequence;
     private versionValue;
@@ -62,6 +111,9 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private spacePressed;
     private dropLine?;
     private paletteDragKind;
+    private palettePointer?;
+    private suppressPaletteClick;
+    private readonly escapePalettePointer;
     private narrowValue;
     private suppressClick;
     private resizeObserver?;
@@ -109,6 +161,10 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     }>;
     load(document: D, options?: ProcessLoadOptions): void;
     selectMany(ids: readonly string[]): void;
+    /** Detached mixed selection. Invalid and duplicate IDs are ignored by selectItems. */
+    get selection(): readonly ProcessSelectionItem[];
+    selectItems(items: readonly ProcessSelectionItem[]): void;
+    private clearMixedSelection;
     get headingLevel(): number;
     set headingLevel(value: number);
     get disableConnections(): boolean;
@@ -148,9 +204,12 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     selectLine(id: string | null): void;
     setValidation(checks: readonly ProcessCheck[]): void;
     setValidationAtPath(message: string, path: NodePath): void;
+    private connectionProblem;
     requestEdit(edit: ProcessEdit): void;
+    private editAcceptance;
     undo(): void;
     redo(): void;
+    private requestLayoutEdit;
     private commitLayout;
     move(id: string, x: number, y: number): void;
     private emitPositions;
@@ -184,7 +243,13 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     arrangeSelection(action: 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom' | 'distribute-horizontal' | 'distribute-vertical'): void;
     makeSection(title?: string): void;
     protected setupListeners(): void;
+    private clearClipboard;
+    private copySelection;
+    private pasteClipboard;
+    private duplicateBoxes;
     private onKey;
+    private navigateSelection;
+    private revealBox;
     private pointerDown;
     private distance;
     private pointerMove;
@@ -194,6 +259,7 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private sideAt;
     private lineAt;
     private markDropLine;
+    private paintDropLine;
     private alignedPoint;
     private openChooser;
     private nextEdit;
@@ -211,10 +277,20 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private collectChecks;
     private renderWorld;
     private place;
+    private activatePaletteKind;
+    private paletteLineAt;
+    private paletteFrameAt;
+    private markPaletteDrop;
+    private paletteCanvasPoint;
+    private movePalettePointer;
+    private cancelPalettePointer;
+    private finishPalettePointer;
     private renderPalette;
     private renderChecks;
     private renderField;
     private renderSelection;
+    private renderLocalVariables;
+    private requestLocalVariableEdit;
     private renderSelectionToolbar;
     private updateToolbar;
     private paintViewport;