@unofficialbox/box-open-elements 0.32.0 → 0.34.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;
@@ -85,6 +118,32 @@ export interface ProcessOutlineItem {
     boxId?: string;
     children?: readonly ProcessOutlineItem[];
 }
+/** Host-authored expression presentation; BOE does not infer scope or evaluate CEL. */
+export interface ProcessExpressionField {
+    /** Complete ordered scope; [] suppresses legacy global-variable chips. */
+    variables?: readonly {
+        name: string;
+        description?: string;
+    }[];
+    /** Values greater than one render a textarea. */
+    rows?: number;
+    /** Error feedback uses ProcessField.problem and takes precedence. */
+    feedback?: {
+        message: string;
+        tone?: 'neutral' | 'success';
+    };
+    help?: {
+        summary: string;
+        examples: readonly {
+            expression: string;
+            description: string;
+            segments?: readonly {
+                text: string;
+                format?: 'code' | 'text';
+            }[];
+        }[];
+    };
+}
 /** Host-supplied field values; the modeler draws controls and requests edits. */
 export interface ProcessField {
     key: string;
@@ -101,6 +160,7 @@ export interface ProcessField {
     required?: boolean;
     disabled?: boolean;
     problem?: string;
+    expression?: ProcessExpressionField;
 }
 export interface ProcessPositionSnapshot {
     path?: NodePath;
@@ -153,6 +213,9 @@ export interface ProcessModel<D = unknown, N = unknown> {
     /** 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;
     /**
@@ -197,8 +260,41 @@ 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" | "reset-line";
+    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.
@@ -214,6 +310,8 @@ export interface ProcessEdit {
     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;
@@ -228,11 +326,27 @@ export interface ReversibleProcessEdit {
     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;
@@ -241,6 +355,9 @@ export interface ProcessClipboard {
 }
 /** 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;

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;
@@ -39,6 +81,11 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private selectedIds;
     private clipboard;
     private clipboardSession;
+    private layoutEditSession;
+    private acceptanceNotifications;
+    private deferredNotifications;
+    private notify;
+    private flushAcceptanceNotifications;
     private restoringBoxFocus;
     private selectionToolbarKey;
     private sectionSequence;
@@ -114,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;
@@ -158,6 +209,7 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private editAcceptance;
     undo(): void;
     redo(): void;
+    private requestLayoutEdit;
     private commitLayout;
     move(id: string, x: number, y: number): void;
     private emitPositions;
@@ -180,6 +232,9 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private minimapBounds;
     private bounds;
     protected renderTemplate(): void;
+    private viewMenuDocument?;
+    private syncViewMenuDismissal;
+    private dismissViewMenuOutside;
     private setupPanes;
     private openDrawer;
     private closeDrawer;
@@ -237,6 +292,8 @@ export declare class ProcessModeler<D = ProcessProjection, N = unknown> extends
     private renderChecks;
     private renderField;
     private renderSelection;
+    private renderLocalVariables;
+    private requestLocalVariableEdit;
     private renderSelectionToolbar;
     private updateToolbar;
     private paintViewport;