@foblex/flow 18.3.0 → 18.5.0

package/AI.md

@@ -0,0 +1,69 @@
+# AI Guide for `@foblex/flow`
+
+Use this file as a strict control layer for code generation. Prefer verified package API and examples over assumptions.
+
+## What This Library Is
+
+`@foblex/flow` is an Angular-native library for building node-based editors, workflow builders, and interactive graph UIs.
+It provides rendering, connectors, interactions, selection, zoom, and connection drawing. Your app still owns the graph data.
+
+## Core Mental Model
+
+- The library does **not** own your graph state.
+- Your app owns nodes, groups, connections, ids, validation, and persistence.
+- Angular templates render the current state.
+- User actions emit events from `fDraggable` or model outputs.
+- Your app updates state.
+- Angular rerenders.
+
+## Verified Building Blocks
+
+- `<f-flow>`: root flow host.
+- `<f-canvas>`: canvas/viewport container.
+- `[fNode]` and `[fGroup]`: place nodes and groups in the template.
+- `[fNodeOutput]` with `fOutputId`: output connector.
+- `[fNodeInput]` with `fInputId`: input connector.
+- `[fNodeOutlet]`: outlet-style connector surface for advanced connection creation patterns.
+- `<f-connection>`: render an existing connection between connectors.
+- `<f-connection-for-create>`: optional preview connection used during drag-to-connect UX.
+- `fDraggable` on `<f-flow>`: enables pointer interactions and emits interaction events.
+
+## Hard Rules
+
+- Never invent Inputs, Outputs, methods, directives, or selectors.
+- Do **not** assume React Flow style APIs such as `[nodes]`, `[edges]`, `setNodes()`, `addEdge()`, `useNodesState()`, or similar patterns.
+- Do **not** assume a built-in graph store. The app owns state.
+- Connections are connector-to-connector, not generic node-to-node edges.
+- Template connections use `fOutputId -> fInputId`.
+- Do **not** interpret `[fNodes]` or `[fConnections]` as graph-state inputs. In this package they are content-projection markers used with `ngProjectAs` in some examples.
+- Examples may include app-specific state, layout logic, persistence, undo/redo, toolbars, or validation. Those are example implementations, not built-in package features.
+- Some exports are low-level, compatibility-oriented, or testing-oriented. Do not treat every export from `@foblex/flow` as the recommended app-facing API.
+- If a symbol, selector, event, or behavior is not confirmed in the installed package, say: `not found in @foblex/flow`.
+
+## Correct Usage Pattern
+
+- Render nodes and groups from your Angular state using normal Angular templates.
+- Put connectors on the node element itself or on child elements with `fNodeOutput` / `fNodeInput`.
+- Render persisted connections explicitly with `<f-connection>`.
+- Add `fDraggable` to `<f-flow>` when you want drag, selection, connect, reassign, or drop interactions.
+- Handle events such as `fCreateConnection`, `fReassignConnection`, `fMoveNodes`, `fSelectionChange`, `fCreateNode`, `fDropToGroup`, and `fConnectionWaypointsChanged`.
+- Update your own state in those handlers, then let Angular rerender.
+- Use node/group position bindings and change outputs to keep positions in app state when needed.
+
+## Naming Distinction
+
+- In templates, connector ids are `fOutputId` and `fInputId`.
+- In `FCreateConnectionEvent`, prefer `sourceId`, `targetId`, and `dropPosition`.
+- `FCreateConnectionEvent` still exposes legacy aliases `fOutputId`, `fInputId`, and `fDropPosition`.
+- In `FReassignConnectionEvent`, prefer `connectionId`, `endpoint`, `previousSourceId`, `nextSourceId`, `previousTargetId`, `nextTargetId`, and `dropPosition`.
+- `FReassignConnectionEvent` still exposes legacy aliases such as `oldSourceId`, `newSourceId`, `oldTargetId`, `newTargetId`, and `dropPoint`.
+- Other current event classes also prefer non-`f*` names when both versions exist, for example `nodeIds` over `fNodeIds` and `nodes` over `fNodes`.
+- Examples may still show compatibility names in handlers. Prefer the current non-deprecated event property names when generating new code.
+
+## Styling
+
+See [STYLING.md](./STYLING.md).
+
+## Fallback Rule
+
+If something cannot be verified from the installed package, answer with: `not found in @foblex/flow`.

package/README.md

@@ -23,14 +23,14 @@ Foblex Flow gives Angular teams a simple way to start building graph-based produ
 
 Use it to create workflow builders, AI low-code tools, call-flow editors, UML diagrams, internal back-office tools, and other node-based interfaces while keeping your own state, validation, persistence, and domain logic.
 
-It works with Angular 15+, SSR, standalone components, and zoneless-friendly application setups.
+Current `18.x` releases target Angular `17.3+`. If your app is on Angular 12-17.2, check the [Angular Version Compatibility](https://flow.foblex.com/docs/angular-version-compatibility) guide first and pin the matching Foblex Flow line before installing.
 
 ## Why Foblex Flow
 
 - Easy starting path: most editors begin with `f-flow`, `f-canvas`, nodes, connectors, and connections.
 - Angular-first API that fits Angular apps instead of wrapping a React-style state model.
 - Built for real editor interactions: drag to connect, drag to reassign, selection, zoom, minimap, snapping, alignment helpers, and waypoints.
-- Advanced modules are optional: caching, virtualization, and the connection worker are scaling tools, not day-one requirements.
+- Advanced modules are optional: caching and virtualization are scaling tools, not day-one requirements.
 - Custom nodes, connectors, and connections for domain-specific graph UIs.
 - Your app stays in control of graph state, validation rules, permissions, and persistence.
 - Suitable for both lightweight diagrams and full workflow-builder products.
@@ -46,23 +46,60 @@ It works with Angular 15+, SSR, standalone components, and zoneless-friendly app
 ## Examples
 
 - [AI Low-Code Platform](https://flow.foblex.com/examples/ai-low-code-platform) - A flagship front-end-only AI low-code IDE demo with custom nodes, JSON import/export, multiple themes, config panels with validation, validation feedback on nodes, undo/redo, persistence, multi-select, and animated connections.
-- [DB Management](https://flow.foblex.com/examples/f-db-management-flow) - A database-oriented workflow builder with richer interactions and UI patterns.
+- [Call Center Flow](https://flow.foblex.com/examples/call-center) - A workflow-builder reference app for IVR routing, queueing, operator handoff, transfer, voicemail, and embedded node forms.
+- [Schema Designer](https://flow.foblex.com/examples/schema-designer) - A richer schema editor demo with nodes, relations, and CRUD-style interactions.
 - [UML Diagram](https://flow.foblex.com/examples/uml-diagram-example) - An Angular example for architecture and UML-style graph interfaces.
 - [Tournament Bracket](https://flow.foblex.com/examples/tournament-bracket) - A specialized bracket UI built on the same node-based primitives.
 - [All Examples](https://flow.foblex.com/examples/overview) - Focused examples for connections, selection, minimap, layout, alignment, and other editor features.
 
 ## Install
 
+These install commands are for the current `18.x` line. For Angular 12-17.2 apps, use the [Angular Version Compatibility](https://flow.foblex.com/docs/angular-version-compatibility) guide first so you do not accidentally install a newer incompatible line.
+
 ```bash
 ng add @foblex/flow
 ```
 
-If you prefer manual installation:
+For Nx workspaces:
+
+```bash
+nx g @foblex/flow:add
+```
+
+`ng add` installs the required companion packages automatically. If you prefer manual installation, install them explicitly:
 
 ```bash
-npm install @foblex/flow
+npm install @foblex/flow @foblex/platform@^1.0.4 @foblex/mediator@^1.1.3 @foblex/2d@^1.2.2 @foblex/utils@^1.1.1
 ```
 
+`ng add` also wires the shipped default theme into application styles by adding `node_modules/@foblex/flow/styles/default.scss` when the entry is missing.
+
+## Default Theme
+
+Use the default theme when you want styled nodes, connectors, connections, minimap, selection area, and helper plugins immediately.
+
+```json
+"styles": [
+  "src/styles.scss",
+  "node_modules/@foblex/flow/styles/default.scss"
+]
+```
+
+If you prefer selective SCSS mixins instead of one full entrypoint:
+
+```scss
+@use '@foblex/flow/styles' as flow-theme;
+
+@include flow-theme.theme-tokens();
+@include flow-theme.flow-canvas();
+@include flow-theme.node-group();
+@include flow-theme.connector();
+@include flow-theme.connection-all();
+@include flow-theme.plugins();
+```
+
+Full guide: [Default Theme and Styling](https://flow.foblex.com/docs/default-theme-and-styling)
+
 ## Minimal Example
 
 ```html
@@ -98,12 +135,13 @@ npm install @foblex/flow
 ## Quick FAQ
 
 - **Is Foblex Flow hard to use?** No. The core setup is small and Angular-native.
-- **Do I need caching, virtualization, or the connection worker?** No. Most editors do not need them on day one. They are optional scaling tools for larger scenes.
+- **Do I need caching or virtualization?** No. Most editors do not need them on day one. They are optional scaling tools for larger scenes.
 - **Who is it for?** Angular teams building node editors, workflow builders, interactive diagrams, and other graph-based product UIs.
 
 ## Resources
 
 - [Get Started](https://flow.foblex.com/docs/get-started)
+- [Angular Version Compatibility](https://flow.foblex.com/docs/angular-version-compatibility)
 - [Documentation](https://flow.foblex.com/docs/intro)
 - [Examples](https://flow.foblex.com/examples/overview)
 - [Articles](https://flow.foblex.com/blog/overview)

package/STYLING.md

@@ -0,0 +1,35 @@
+# Styling Guide for `@foblex/flow`
+
+## Introduction
+
+Styling in `@foblex/flow` depends partly on CSS classes applied by the library at runtime.
+Observed host/base classes in source include `.f-flow`, `.f-canvas`, `.f-node`, `.f-group`, `.f-connection`, `.f-node-input`, `.f-node-output`, and `.f-node-outlet`.
+
+## Observed Runtime Classes
+
+- Observed in source and examples: `.f-selected` for selected nodes, groups, connections, and minimap items.
+- Observed in source: `.f-dragging` is applied during drag sequences. It is used on dragged items and also on the flow host during an active drag sequence.
+- Observed in source and examples: `.f-connections-dragging` is applied while connection creation/reassignment is looking for valid targets.
+- Observed in source and examples: `.f-connector-connectable` marks connectors that are currently valid connection targets.
+- Observed in source: `.f-node-output-connected` and `.f-node-input-connected` mark connectors that are currently connected.
+- Observed in source: `.f-node-output-not-connectable` and `.f-node-input-not-connectable` mark connectors that are present but currently not connectable.
+- Observed in source: `.f-grouping-drop-active` and `.f-grouping-over-boundary` are applied during drop-to-group interactions.
+- Observed in source: `.f-node-dragging-disabled`, `.f-node-selection-disabled`, `.f-group-dragging-disabled`, `.f-group-selection-disabled`, `.f-connection-reassign-disabled`, and `.f-connection-selection-disabled` are host modifier classes for disabled interaction states.
+- Observed in source: `.f-node-input-disabled`, `.f-node-output-disabled`, and `.f-node-outlet-disabled` are connector/outlet disabled-state classes.
+- Observed in source: `.f-node-input-multiple`, `.f-node-output-multiple`, and `.f-node-output-self-connectable` are connector capability/modifier classes.
+
+## Safe Styling Approach
+
+- Prefer styling your own semantic classes first, then combine them with high-level Foblex host classes.
+- Safe selectors usually start from host elements such as `.f-node`, `.f-group`, `.f-connection`, `.f-node-input`, `.f-node-output`, and `.f-node-outlet`.
+- For state styling, prefer selectors like `.my-node.f-selected`, `.my-connector.f-node-input-connected`, or `f-flow.f-connections-dragging .f-node-input`.
+- Avoid depending on deep internal DOM structure for connections, markers, or helper overlays unless you inspect the runtime DOM in the installed version.
+- If you need a very specific selector, inspect the rendered DOM first instead of assuming structure from examples.
+
+## Warnings
+
+- Not every runtime class should be treated as stable public styling API.
+- Some classes are clearly internal interaction/animation helpers, for example `.f-canvas-dragging`, `.f-scaled-animate`, `.f-external-item-preview`, and `.f-external-item-placeholder`.
+- `.canvas-dragging` is a deprecated compatibility alias. Prefer `.f-canvas-dragging`.
+- Example styles prove that a class exists, not that it is guaranteed stable across versions.
+- If a class is not verified in source or shipped examples, do not invent it. Say: `not found in @foblex/flow`.

package/domain/f-canvas/redraw-canvas-with-animation/e-canvas-redraw-context.d.ts

@@ -0,0 +1,4 @@
+export declare enum ECanvasRedrawContext {
+    VIEWPORT_ONLY = "VIEWPORT_ONLY",
+    WITH_CONNECTION_CHANGES = "WITH_CONNECTION_CHANGES"
+}

package/domain/f-canvas/redraw-canvas-with-animation/index.d.ts

@@ -1,2 +1,3 @@
 export * from './redraw-canvas-with-animation';
+export * from './e-canvas-redraw-context';
 export * from './redraw-canvas-with-animation-request';

package/domain/f-canvas/redraw-canvas-with-animation/redraw-canvas-with-animation-request.d.ts

@@ -1,5 +1,7 @@
+import { ECanvasRedrawContext } from './e-canvas-redraw-context';
 export declare class RedrawCanvasWithAnimationRequest {
-    animated: boolean;
+    readonly animated: boolean;
+    readonly context: ECanvasRedrawContext;
     static readonly fToken: unique symbol;
-    constructor(animated: boolean);
+    constructor(animated: boolean, context?: ECanvasRedrawContext);
 }

package/domain/f-connection/add-connection-marker-to-store/add-connection-marker-to-store-request.d.ts

@@ -1,4 +1,4 @@
-import { FConnectionMarkerBase } from '../../../f-connection-v2';
+import { FConnectionMarkerBase } from '../../../f-connection-v2/components/connection-marker/models';
 export declare class AddConnectionMarkerToStoreRequest {
     readonly instance: FConnectionMarkerBase;
     static readonly fToken: unique symbol;

package/domain/f-connection/create-connection-markers/create-connection-markers.d.ts

@@ -7,7 +7,6 @@ import * as i0 from "@angular/core";
  */
 export declare class CreateConnectionMarkers implements IExecution<CreateConnectionMarkersRequest, boolean> {
     private readonly _browser;
-    private readonly _store;
     private readonly _markerCache;
     handle({ connection }: CreateConnectionMarkersRequest): boolean;
     _findConnectionMarkers(connection: FConnectionBase): FConnectionMarkerBase[];

package/domain/f-connection/index.d.ts

@@ -4,6 +4,7 @@ export * from './add-connection-to-store';
 export * from './add-snap-connection-to-store';
 export * from './create-connection-markers';
 export * from './redraw-connections';
+export * from './resolve-connection-endpoint-rotation-context';
 export * from './remove-connection-for-create-from-store';
 export * from './remove-connection-from-store';
 export * from './remove-connection-marker-from-store';

package/domain/f-connection/providers.d.ts

@@ -1,15 +1,16 @@
-import { CreateConnectionMarkers } from './create-connection-markers';
 import { AddConnectionForCreateToStore } from './add-connection-for-create-to-store';
+import { AddConnectionMarkerToStore } from './add-connection-marker-to-store';
 import { AddConnectionToStore } from './add-connection-to-store';
 import { AddSnapConnectionToStore } from './add-snap-connection-to-store';
+import { CreateConnectionMarkers } from './create-connection-markers';
+import { ApplyConnectionRender, ApplyConnectionWorkerResult, BuildConnectionLine, BuildConnectionWorkerBatch, BuildConnectionWorkerPayloadItem, CompleteConnectionRedraw, ConnectionRedrawState, ConnectionWorkerState, DisableConnectionWorker, EnsureConnectionWorker, HandleConnectionWorkerMessage, IsConnectionRedrawCurrent, IsConnectionWorkerEnabled, MarkConnectionConnectorsAsConnected, RedrawConnections, RenderConnection, RenderConnectionFromGeometry, RenderConnectionWithLine, ResolveConnectionEndpointRect, ResolveConnectionEndpoints, ResolveConnectionGeometry, ResetConnectionWorkerRuntime, RunConnectionRedrawSlice, RunConnectionWorker, RunConnectionWorkerBatch, ShouldUseConnectionWorker, StartConnectionRedraw, StartConnectionWorkerRedraw } from './redraw-connections';
 import { RemoveConnectionForCreateFromStore } from './remove-connection-for-create-from-store';
 import { RemoveConnectionFromStore } from './remove-connection-from-store';
-import { RemoveSnapConnectionFromStore } from './remove-snap-connection-from-store';
-import { AddConnectionMarkerToStore } from './add-connection-marker-to-store';
 import { RemoveConnectionMarkerFromStore } from './remove-connection-marker-from-store';
-import { RedrawConnections } from './redraw-connections';
 import { RemoveConnectionWaypoint } from './remove-connection-waypoint';
+import { RemoveSnapConnectionFromStore } from './remove-snap-connection-from-store';
+import { ResolveConnectionEndpointRotationContext } from './resolve-connection-endpoint-rotation-context';
 /**
  * This file exports all the connection-related features for the F-Flow domain.
  */
-export declare const F_CONNECTION_FEATURES: (typeof AddConnectionForCreateToStore | typeof AddConnectionMarkerToStore | typeof AddConnectionToStore | typeof AddSnapConnectionToStore | typeof CreateConnectionMarkers | typeof RedrawConnections | typeof RemoveConnectionForCreateFromStore | typeof RemoveConnectionFromStore | typeof RemoveConnectionMarkerFromStore | typeof RemoveSnapConnectionFromStore | typeof RemoveConnectionWaypoint)[];
+export declare const F_CONNECTION_FEATURES: (typeof ConnectionRedrawState | typeof ConnectionWorkerState | typeof AddConnectionForCreateToStore | typeof AddConnectionMarkerToStore | typeof AddConnectionToStore | typeof AddSnapConnectionToStore | typeof CreateConnectionMarkers | typeof ApplyConnectionWorkerResult | typeof ApplyConnectionRender | typeof BuildConnectionLine | typeof BuildConnectionWorkerBatch | typeof BuildConnectionWorkerPayloadItem | typeof CompleteConnectionRedraw | typeof DisableConnectionWorker | typeof EnsureConnectionWorker | typeof HandleConnectionWorkerMessage | typeof IsConnectionRedrawCurrent | typeof IsConnectionWorkerEnabled | typeof MarkConnectionConnectorsAsConnected | typeof RedrawConnections | typeof RenderConnection | typeof RenderConnectionFromGeometry | typeof RenderConnectionWithLine | typeof ResolveConnectionEndpointRect | typeof ResolveConnectionEndpointRotationContext | typeof ResolveConnectionEndpoints | typeof ResolveConnectionGeometry | typeof ResetConnectionWorkerRuntime | typeof RunConnectionRedrawSlice | typeof RunConnectionWorker | typeof RunConnectionWorkerBatch | typeof ShouldUseConnectionWorker | typeof StartConnectionRedraw | typeof StartConnectionWorkerRedraw | typeof RemoveConnectionForCreateFromStore | typeof RemoveConnectionFromStore | typeof RemoveConnectionMarkerFromStore | typeof RemoveSnapConnectionFromStore | typeof RemoveConnectionWaypoint)[];

package/domain/f-connection/redraw-connections/index.d.ts

@@ -1,2 +1,7 @@
+export * from './models';
+export * from './main-thread';
+export * from './pipeline';
 export * from './redraw-connections';
 export * from './redraw-connections-request';
+export * from './shared';
+export * from './worker';

package/domain/f-connection/redraw-connections/main-thread/apply-connection-render/apply-connection-render-request.d.ts

@@ -0,0 +1,8 @@
+import { ILine } from '@foblex/2d';
+import { FConnectionBase } from '../../../../../f-connection-v2';
+export declare class ApplyConnectionRenderRequest {
+    connection: FConnectionBase;
+    line: ILine;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase, line: ILine);
+}

package/domain/f-connection/redraw-connections/main-thread/apply-connection-render/apply-connection-render.d.ts

@@ -0,0 +1,15 @@
+import { IExecution } from '@foblex/mediator';
+import { ApplyConnectionRenderRequest } from './apply-connection-render-request';
+import * as i0 from "@angular/core";
+export declare class ApplyConnectionRender implements IExecution<ApplyConnectionRenderRequest, void> {
+    private readonly _mediator;
+    private readonly _renderCache;
+    handle({ connection, line }: ApplyConnectionRenderRequest): void;
+    private _shouldRender;
+    private _createConnectionRenderSignature;
+    private _serializePoint;
+    private _serializeWaypoints;
+    private _serializeContents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyConnectionRender, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplyConnectionRender>;
+}

package/domain/f-connection/redraw-connections/main-thread/apply-connection-render/index.d.ts

@@ -0,0 +1,2 @@
+export * from './apply-connection-render';
+export * from './apply-connection-render-request';

package/domain/f-connection/redraw-connections/main-thread/index.d.ts

@@ -0,0 +1,5 @@
+export * from './apply-connection-render';
+export * from './mark-connection-connectors-as-connected';
+export * from './render-connection';
+export * from './render-connection-from-geometry';
+export * from './render-connection-with-line';

package/domain/f-connection/redraw-connections/main-thread/mark-connection-connectors-as-connected/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mark-connection-connectors-as-connected';
+export * from './mark-connection-connectors-as-connected-request';

package/domain/f-connection/redraw-connections/main-thread/mark-connection-connectors-as-connected/mark-connection-connectors-as-connected-request.d.ts

@@ -0,0 +1,7 @@
+import { FConnectorBase } from '../../../../../f-connectors';
+export declare class MarkConnectionConnectorsAsConnectedRequest {
+    source: FConnectorBase;
+    target: FConnectorBase;
+    static readonly fToken: unique symbol;
+    constructor(source: FConnectorBase, target: FConnectorBase);
+}

package/domain/f-connection/redraw-connections/main-thread/mark-connection-connectors-as-connected/mark-connection-connectors-as-connected.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { MarkConnectionConnectorsAsConnectedRequest } from './mark-connection-connectors-as-connected-request';
+import * as i0 from "@angular/core";
+export declare class MarkConnectionConnectorsAsConnected implements IExecution<MarkConnectionConnectorsAsConnectedRequest, void> {
+    private readonly _state;
+    handle({ source, target }: MarkConnectionConnectorsAsConnectedRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkConnectionConnectorsAsConnected, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MarkConnectionConnectorsAsConnected>;
+}

package/domain/f-connection/redraw-connections/main-thread/render-connection/index.d.ts

@@ -0,0 +1,2 @@
+export * from './render-connection';
+export * from './render-connection-request';

package/domain/f-connection/redraw-connections/main-thread/render-connection/render-connection-request.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../../../f-connection-v2';
+export declare class RenderConnectionRequest {
+    connection: FConnectionBase;
+    cache: Map<string, IRoundedRect>;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase, cache: Map<string, IRoundedRect>);
+}

package/domain/f-connection/redraw-connections/main-thread/render-connection/render-connection.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { RenderConnectionRequest } from './render-connection-request';
+import * as i0 from "@angular/core";
+export declare class RenderConnection implements IExecution<RenderConnectionRequest, void> {
+    private readonly _mediator;
+    handle({ connection, cache }: RenderConnectionRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderConnection, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderConnection>;
+}

package/domain/f-connection/redraw-connections/main-thread/render-connection-from-geometry/index.d.ts

@@ -0,0 +1,2 @@
+export * from './render-connection-from-geometry';
+export * from './render-connection-from-geometry-request';

package/domain/f-connection/redraw-connections/main-thread/render-connection-from-geometry/render-connection-from-geometry-request.d.ts

@@ -0,0 +1,8 @@
+import { FConnectionBase } from '../../../../../f-connection-v2';
+import { IConnectionGeometry } from '../../models';
+export declare class RenderConnectionFromGeometryRequest {
+    connection: FConnectionBase;
+    geometry: IConnectionGeometry;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase, geometry: IConnectionGeometry);
+}

package/domain/f-connection/redraw-connections/main-thread/render-connection-from-geometry/render-connection-from-geometry.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { RenderConnectionFromGeometryRequest } from './render-connection-from-geometry-request';
+import * as i0 from "@angular/core";
+export declare class RenderConnectionFromGeometry implements IExecution<RenderConnectionFromGeometryRequest, void> {
+    private readonly _mediator;
+    handle({ connection, geometry }: RenderConnectionFromGeometryRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderConnectionFromGeometry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderConnectionFromGeometry>;
+}

package/domain/f-connection/redraw-connections/main-thread/render-connection-with-line/index.d.ts

@@ -0,0 +1,2 @@
+export * from './render-connection-with-line';
+export * from './render-connection-with-line-request';

package/domain/f-connection/redraw-connections/main-thread/render-connection-with-line/render-connection-with-line-request.d.ts

@@ -0,0 +1,11 @@
+import { ILine } from '@foblex/2d';
+import { FConnectorBase } from '../../../../../f-connectors';
+import { FConnectionBase } from '../../../../../f-connection-v2';
+export declare class RenderConnectionWithLineRequest {
+    connection: FConnectionBase;
+    source: FConnectorBase;
+    target: FConnectorBase;
+    line: ILine;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase, source: FConnectorBase, target: FConnectorBase, line: ILine);
+}

package/domain/f-connection/redraw-connections/main-thread/render-connection-with-line/render-connection-with-line.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { RenderConnectionWithLineRequest } from './render-connection-with-line-request';
+import * as i0 from "@angular/core";
+export declare class RenderConnectionWithLine implements IExecution<RenderConnectionWithLineRequest, void> {
+    private readonly _mediator;
+    handle({ connection, source, target, line }: RenderConnectionWithLineRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderConnectionWithLine, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RenderConnectionWithLine>;
+}

package/domain/f-connection/redraw-connections/models/connection-redraw-state.d.ts

@@ -0,0 +1,11 @@
+import { FConnectorBase } from '../../../../f-connectors';
+import * as i0 from "@angular/core";
+export declare class ConnectionRedrawState {
+    renderTicket: number;
+    private readonly _connectedInPreviousRender;
+    beginRender(): number;
+    resetConnectedConnectors(): void;
+    trackConnectedConnectors(source: FConnectorBase, target: FConnectorBase): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionRedrawState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionRedrawState>;
+}

package/domain/f-connection/redraw-connections/models/connection-worker-state.d.ts

@@ -0,0 +1,13 @@
+import { TConnectionWorkerPendingRequest } from './t-connection-worker-pending-request';
+import * as i0 from "@angular/core";
+export declare class ConnectionWorkerState {
+    worker: Worker | null;
+    workerUrl: string | null;
+    nextRequestId: number;
+    isDisabled: boolean;
+    pending: Map<number, TConnectionWorkerPendingRequest>;
+    resetRuntime(error: Error): void;
+    dispose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionWorkerState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionWorkerState>;
+}

package/domain/f-connection/redraw-connections/models/i-connection-endpoints.d.ts

@@ -0,0 +1,5 @@
+import { FConnectorBase } from '../../../../f-connectors';
+export interface IConnectionEndpoints {
+    source: FConnectorBase;
+    target: FConnectorBase;
+}

package/domain/f-connection/redraw-connections/models/i-connection-geometry.d.ts

@@ -0,0 +1,6 @@
+import { IRoundedRect } from '@foblex/2d';
+import { IConnectionEndpoints } from './i-connection-endpoints';
+export interface IConnectionGeometry extends IConnectionEndpoints {
+    sourceRect: IRoundedRect;
+    targetRect: IRoundedRect;
+}

package/domain/f-connection/redraw-connections/models/i-connection-redraw-session.d.ts

@@ -0,0 +1,5 @@
+export interface IConnectionRedrawSession {
+    renderTicket: number;
+    connectionsRevision: number;
+    nodesRevision: number;
+}

package/domain/f-connection/redraw-connections/models/i-connection-worker-batch-item.d.ts

@@ -0,0 +1,8 @@
+import { FConnectionBase } from '../../../../f-connection-v2';
+import { IConnectionGeometry } from './i-connection-geometry';
+import { IConnectionWorkerPayloadItem } from './i-connection-worker-payload-item';
+export interface IConnectionWorkerBatchItem {
+    connection: FConnectionBase;
+    geometry: IConnectionGeometry;
+    payload: IConnectionWorkerPayloadItem;
+}

package/domain/f-connection/redraw-connections/models/i-connection-worker-batch.d.ts

@@ -0,0 +1,6 @@
+import { IConnectionWorkerBatchItem } from './i-connection-worker-batch-item';
+import { IConnectionWorkerPayloadItem } from './i-connection-worker-payload-item';
+export interface IConnectionWorkerBatch {
+    items: (IConnectionWorkerBatchItem | null)[];
+    payload: IConnectionWorkerPayloadItem[];
+}

package/domain/f-connection/redraw-connections/models/i-connection-worker-payload-item.d.ts

@@ -0,0 +1,13 @@
+import { IConnectionWorkerRect } from './i-connection-worker-rect';
+export interface IConnectionWorkerPayloadItem {
+    originalIndex: number;
+    behavior: string;
+    outputSide: string;
+    inputSide: string;
+    sourceConnectableSide: string;
+    targetConnectableSide: string;
+    sourceRotation: number;
+    targetRotation: number;
+    sourceRect: IConnectionWorkerRect;
+    targetRect: IConnectionWorkerRect;
+}

package/domain/f-connection/redraw-connections/models/i-connection-worker-rect.d.ts

@@ -0,0 +1,10 @@
+export interface IConnectionWorkerRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius1: number;
+    radius2: number;
+    radius3: number;
+    radius4: number;
+}

package/domain/f-connection/redraw-connections/models/i-connection-worker-response.d.ts

@@ -0,0 +1,6 @@
+import { IConnectionWorkerResultItem } from './i-connection-worker-result-item';
+export interface IConnectionWorkerResponse {
+    requestId: number;
+    results?: IConnectionWorkerResultItem[];
+    error?: string;
+}

package/{f-connection-worker/model/i-f-connection-worker-result-item.d.ts → domain/f-connection/redraw-connections/models/i-connection-worker-result-item.d.ts}

@@ -1,6 +1,6 @@
 import { ILine } from '@foblex/2d';
-export interface IFConnectionWorkerResultItem {
-    originalIndex?: number;
+export interface IConnectionWorkerResultItem {
+    originalIndex: number;
     supported: boolean;
     sourceSide?: string;
     targetSide?: string;

package/domain/f-connection/redraw-connections/models/index.d.ts

@@ -0,0 +1,12 @@
+export * from './connection-redraw-state';
+export * from './connection-worker-state';
+export * from './i-connection-endpoints';
+export * from './i-connection-geometry';
+export * from './i-connection-redraw-session';
+export * from './i-connection-worker-batch';
+export * from './i-connection-worker-batch-item';
+export * from './i-connection-worker-payload-item';
+export * from './i-connection-worker-rect';
+export * from './i-connection-worker-response';
+export * from './i-connection-worker-result-item';
+export * from './t-connection-worker-pending-request';

package/domain/f-connection/redraw-connections/models/t-connection-worker-pending-request.d.ts

@@ -0,0 +1,5 @@
+import { IConnectionWorkerResultItem } from './i-connection-worker-result-item';
+export type TConnectionWorkerPendingRequest = {
+    resolve: (value: IConnectionWorkerResultItem[]) => void;
+    reject: (error: Error) => void;
+};

package/domain/f-connection/redraw-connections/pipeline/complete-connection-redraw/complete-connection-redraw-request.d.ts

@@ -0,0 +1,6 @@
+import { IConnectionRedrawSession } from '../../models';
+export declare class CompleteConnectionRedrawRequest {
+    session: IConnectionRedrawSession;
+    static readonly fToken: unique symbol;
+    constructor(session: IConnectionRedrawSession);
+}

package/domain/f-connection/redraw-connections/pipeline/complete-connection-redraw/complete-connection-redraw.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { CompleteConnectionRedrawRequest } from './complete-connection-redraw-request';
+import * as i0 from "@angular/core";
+export declare class CompleteConnectionRedraw implements IExecution<CompleteConnectionRedrawRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    handle({ session }: CompleteConnectionRedrawRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompleteConnectionRedraw, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CompleteConnectionRedraw>;
+}

package/domain/f-connection/redraw-connections/pipeline/complete-connection-redraw/index.d.ts

@@ -0,0 +1,2 @@
+export * from './complete-connection-redraw';
+export * from './complete-connection-redraw-request';

package/domain/f-connection/redraw-connections/pipeline/index.d.ts

@@ -0,0 +1,4 @@
+export * from './complete-connection-redraw';
+export * from './is-connection-redraw-current';
+export * from './run-connection-redraw-slice';
+export * from './start-connection-redraw';

package/domain/f-connection/redraw-connections/pipeline/is-connection-redraw-current/index.d.ts

@@ -0,0 +1,2 @@
+export * from './is-connection-redraw-current';
+export * from './is-connection-redraw-current-request';

package/domain/f-connection/redraw-connections/pipeline/is-connection-redraw-current/is-connection-redraw-current-request.d.ts

@@ -0,0 +1,6 @@
+import { IConnectionRedrawSession } from '../../models';
+export declare class IsConnectionRedrawCurrentRequest {
+    session: IConnectionRedrawSession;
+    static readonly fToken: unique symbol;
+    constructor(session: IConnectionRedrawSession);
+}

package/domain/f-connection/redraw-connections/pipeline/is-connection-redraw-current/is-connection-redraw-current.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { IsConnectionRedrawCurrentRequest } from './is-connection-redraw-current-request';
+import * as i0 from "@angular/core";
+export declare class IsConnectionRedrawCurrent implements IExecution<IsConnectionRedrawCurrentRequest, boolean> {
+    private readonly _store;
+    private readonly _state;
+    handle({ session }: IsConnectionRedrawCurrentRequest): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsConnectionRedrawCurrent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IsConnectionRedrawCurrent>;
+}