@foblex/flow 18.1.2 → 18.2.0

package/f-draggable/resize-node/constraint/i-resize-constraint.d.ts

@@ -0,0 +1,7 @@
+import { IRect, ISize } from '@foblex/2d';
+import { IResizeLimits } from './i-resize-limits';
+export interface IResizeConstraint {
+    limits: IResizeLimits;
+    childrenBounds: IRect | null;
+    minimumSize: ISize;
+}

package/f-draggable/resize-node/constraint/i-resize-limit.d.ts

@@ -0,0 +1,7 @@
+import { IRect } from '@foblex/2d';
+import { FNodeBase } from '../../../f-node';
+export interface IResizeLimit {
+    boundingRect: IRect;
+    innerRect: IRect;
+    nodeOrGroup: FNodeBase;
+}

package/f-draggable/resize-node/constraint/i-resize-limits.d.ts

@@ -0,0 +1,5 @@
+import { IResizeLimit } from './i-resize-limit';
+export interface IResizeLimits {
+    softLimits: IResizeLimit[];
+    hardLimit: IResizeLimit | undefined;
+}

package/f-draggable/resize-node/constraint/index.d.ts

@@ -0,0 +1,5 @@
+export * from './i-resize-constraint';
+export * from './i-resize-limit';
+export * from './i-resize-limits';
+export * from './i-resize-overflow';
+export * from './resize-direction';

package/f-draggable/resize-node/f-resize-node-start-event-data.d.ts

@@ -0,0 +1,4 @@
+export declare class FResizeNodeStartEventData {
+    readonly fNodeId: string;
+    constructor(fNodeId: string);
+}

package/f-draggable/resize-node/index.d.ts

@@ -0,0 +1,12 @@
+export * from './apply-child-resize-constraints';
+export * from './apply-parent-resize-constraints';
+export * from './calculate-changed-rect-from-difference';
+export * from './calculate-direct-children-union-rect';
+export * from './calculate-resize-limits';
+export * from './constraint';
+export * from './resize-node-finalize';
+export * from './resize-node-handler';
+export * from './resize-preparation';
+export * from './f-resize-node-start-event-data';
+export * from './is-resize-node-handler';
+export * from './providers';

package/f-draggable/resize-node/is-resize-node-handler.d.ts

@@ -0,0 +1,5 @@
+import { DragHandlerBase } from '../infrastructure';
+import { ResizeNodeHandler } from './resize-node-handler';
+export declare const RESIZE_NODE_HANDLER_TYPE = "node-resize";
+export declare const RESIZE_NODE_HANDLER_KIND = "resize-node";
+export declare function isResizeNodeHandler(value: DragHandlerBase<unknown>): value is ResizeNodeHandler;

package/f-draggable/resize-node/providers.d.ts

@@ -0,0 +1,9 @@
+import { ResizeNodeFinalize } from './resize-node-finalize';
+import { ResizeNodePreparation } from './resize-preparation';
+import { CalculateResizeLimits } from './calculate-resize-limits';
+import { ApplyChildResizeConstraints } from './apply-child-resize-constraints';
+import { ApplyParentResizeConstraints } from './apply-parent-resize-constraints';
+import { CalculateChangedRectFromDifference } from './calculate-changed-rect-from-difference';
+import { CalculateDirectChildrenUnionRect } from './calculate-direct-children-union-rect';
+import { AttachResizeConnectionDragHandlersToNode } from './resize-preparation';
+export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeConstraints | typeof ApplyParentResizeConstraints | typeof CalculateChangedRectFromDifference | typeof CalculateDirectChildrenUnionRect | typeof CalculateResizeLimits | typeof ResizeNodeFinalize | typeof AttachResizeConnectionDragHandlersToNode | typeof ResizeNodePreparation)[];

package/f-draggable/resize-node/resize-node-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resize-node-finalize';
+export * from './resize-node-finalize-request';

package/f-draggable/resize-node/resize-node-finalize/resize-node-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class ResizeNodeFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/resize-node/resize-node-finalize/resize-node-finalize.d.ts

@@ -0,0 +1,10 @@
+import { ResizeNodeFinalizeRequest } from './resize-node-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeFinalize implements IExecution<ResizeNodeFinalizeRequest, void> {
+    private readonly _dragSession;
+    handle(_request: ResizeNodeFinalizeRequest): void;
+    private _isNodeResizeHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeFinalize>;
+}

package/f-draggable/resize-node/resize-node-handler/i-resize-node-connection-handlers.d.ts

@@ -0,0 +1,10 @@
+import { ResizeNodeConnectionHandlerBase } from './resize-node-dependent-connection-handlers';
+import { FConnectorBase } from '../../../f-connectors';
+export interface IResizeNodeConnectionEndpointHandler {
+    handler: ResizeNodeConnectionHandlerBase;
+    connector: FConnectorBase;
+}
+export interface IResizeNodeConnectionHandlers {
+    source: IResizeNodeConnectionEndpointHandler[];
+    target: IResizeNodeConnectionEndpointHandler[];
+}

package/f-draggable/resize-node/resize-node-handler/index.d.ts

@@ -0,0 +1,3 @@
+export * from './resize-node-handler';
+export * from './i-resize-node-connection-handlers';
+export * from './resize-node-dependent-connection-handlers';

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './resize-node-connection-both-sides-handler';
+export * from './resize-node-connection-handler-base';
+export * from './resize-node-connection-source-handler';
+export * from './resize-node-connection-target-handler';

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-both-sides-handler.d.ts

@@ -0,0 +1,12 @@
+import { IRoundedRect } from '@foblex/2d';
+import { ResizeNodeConnectionHandlerBase } from './resize-node-connection-handler-base';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeConnectionBothSidesHandler extends ResizeNodeConnectionHandlerBase {
+    private _sourceUpdated;
+    private _targetUpdated;
+    setSourceRect(rect: IRoundedRect): void;
+    setTargetRect(rect: IRoundedRect): void;
+    private _redrawIfReady;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionBothSidesHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionBothSidesHandler>;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-handler-base.d.ts

@@ -0,0 +1,20 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../../f-connection-v2';
+export declare class ResizeNodeConnectionHandlerBase {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _behaviour;
+    private _source;
+    private _target;
+    private _sourceRef;
+    private _targetRef;
+    private _sourceRect;
+    private _targetRect;
+    connection: FConnectionBase;
+    initialize(connection: FConnectionBase): void;
+    setSourceRect(rect: IRoundedRect): void;
+    setTargetRect(rect: IRoundedRect): void;
+    protected redraw(): void;
+    private _buildLine;
+    private _readRectRef;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-source-handler.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { ResizeNodeConnectionHandlerBase } from './resize-node-connection-handler-base';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeConnectionSourceHandler extends ResizeNodeConnectionHandlerBase {
+    setSourceRect(rect: IRoundedRect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionSourceHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionSourceHandler>;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-dependent-connection-handlers/resize-node-connection-target-handler.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { ResizeNodeConnectionHandlerBase } from './resize-node-connection-handler-base';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeConnectionTargetHandler extends ResizeNodeConnectionHandlerBase {
+    setTargetRect(rect: IRoundedRect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeConnectionTargetHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeConnectionTargetHandler>;
+}

package/f-draggable/resize-node/resize-node-handler/resize-node-handler.d.ts

@@ -0,0 +1,35 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { EFResizeHandleType, FNodeBase } from '../../../f-node';
+import { FResizeNodeStartEventData } from '../f-resize-node-start-event-data';
+import { IResizeNodeConnectionHandlers } from './i-resize-node-connection-handlers';
+import * as i0 from "@angular/core";
+export declare class ResizeNodeHandler extends DragHandlerBase<FResizeNodeStartEventData> {
+    protected readonly type = "node-resize";
+    protected readonly kind = "resize-node";
+    protected data(): FResizeNodeStartEventData;
+    private readonly _mediator;
+    private _baselineRect;
+    private _constraints;
+    private _lastRect;
+    private _nodeOrGroup;
+    private _handleType;
+    private _nodeConnections;
+    private _softParentConnections;
+    initialize(nodeOrGroup: FNodeBase, handleType: EFResizeHandleType): void;
+    setNodeConnectionHandlers(handlers: IResizeNodeConnectionHandlers): void;
+    setSoftParentConnectionHandlers(handlers: IResizeNodeConnectionHandlers[]): void;
+    prepareDragSequence(): void;
+    onPointerMove(delta: IPoint): void;
+    onPointerUp(): void;
+    private _readBaselineRect;
+    private _buildConstraints;
+    private _calcNextRect;
+    private _applyConstraints;
+    private _commitRect;
+    private _fallbackRectFromModel;
+    private _applyConnectionHandlers;
+    private _readConnectorRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodeHandler>;
+}

package/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/attach-resize-connection-drag-handlers-to-node-request.d.ts

@@ -0,0 +1,8 @@
+import { FNodeBase } from '../../../../f-node';
+import { ResizeNodeHandler } from '../../resize-node-handler';
+export declare class AttachResizeConnectionDragHandlersToNodeRequest {
+    readonly handler: ResizeNodeHandler;
+    readonly nodeOrGroup: FNodeBase;
+    static readonly fToken: unique symbol;
+    constructor(handler: ResizeNodeHandler, nodeOrGroup: FNodeBase);
+}

package/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/attach-resize-connection-drag-handlers-to-node.d.ts

@@ -0,0 +1,16 @@
+import { AttachResizeConnectionDragHandlersToNodeRequest } from './attach-resize-connection-drag-handlers-to-node-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class AttachResizeConnectionDragHandlersToNode implements IExecution<AttachResizeConnectionDragHandlersToNodeRequest, void> {
+    private readonly _store;
+    private readonly _mediator;
+    private readonly _dragInjector;
+    handle({ handler, nodeOrGroup }: AttachResizeConnectionDragHandlersToNodeRequest): void;
+    private _readSoftParents;
+    private _collectSourceConnectorIds;
+    private _collectTargetConnectorIds;
+    private _buildConnectionHandlersForNode;
+    private _createConnectionHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachResizeConnectionDragHandlersToNode, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AttachResizeConnectionDragHandlersToNode>;
+}

package/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attach-resize-connection-drag-handlers-to-node';
+export * from './attach-resize-connection-drag-handlers-to-node-request';

package/f-draggable/resize-node/resize-preparation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './resize-node-preparation';
+export * from './resize-node-preparation-request';
+export * from './attach-resize-connection-drag-handlers-to-node';

package/f-draggable/resize-node/resize-preparation/resize-node-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FEventTrigger } from '../../../domain';
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class ResizeNodePreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/resize-node/resize-preparation/resize-node-preparation.d.ts

@@ -0,0 +1,17 @@
+import { ResizeNodePreparationRequest } from './resize-node-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class ResizeNodePreparation implements IExecution<ResizeNodePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    private readonly _dragInjector;
+    private get _transform();
+    handle({ event, fTrigger }: ResizeNodePreparationRequest): void;
+    private _isResizeHandle;
+    private _findResizableNode;
+    private _selectBeforeResize;
+    private _readResizeHandleType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeNodePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeNodePreparation>;
+}

package/f-draggable/rotate-node/f-rotate-node-start-event-data.d.ts

@@ -0,0 +1,4 @@
+export declare class FRotateNodeStartEventData {
+    readonly fNodeId: string;
+    constructor(fNodeId: string);
+}

package/f-draggable/rotate-node/index.d.ts

@@ -0,0 +1,7 @@
+export * from './rotate-node-finalize';
+export * from './rotate-node-preparation';
+export * from './rotate-node-handler';
+export * from './calculate-difference-after-rotation';
+export * from './f-rotate-node-start-event-data';
+export * from './is-rotate-node-handler';
+export * from './providers';

package/f-draggable/rotate-node/is-rotate-node-handler.d.ts

@@ -0,0 +1,5 @@
+import { DragHandlerBase } from '../infrastructure';
+import { RotateNodeHandler } from './rotate-node-handler';
+export declare const ROTATE_NODE_HANDLER_TYPE = "node-rotate";
+export declare const ROTATE_NODE_HANDLER_KIND = "rotate-node";
+export declare function isRotateNodeHandler(value: DragHandlerBase<unknown>): value is RotateNodeHandler;

package/f-draggable/rotate-node/providers.d.ts

@@ -0,0 +1,3 @@
+import { RotateNodeFinalize } from './rotate-node-finalize';
+import { RotateNodePreparation } from './rotate-node-preparation';
+export declare const NODE_ROTATE_PROVIDERS: (typeof RotateNodeFinalize | typeof RotateNodePreparation)[];

package/f-draggable/rotate-node/rotate-node-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rotate-node-finalize';
+export * from './rotate-node-finalize-request';

package/f-draggable/rotate-node/rotate-node-finalize/rotate-node-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class RotateNodeFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/rotate-node/rotate-node-finalize/rotate-node-finalize.d.ts

@@ -0,0 +1,10 @@
+import { RotateNodeFinalizeRequest } from './rotate-node-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class RotateNodeFinalize implements IExecution<RotateNodeFinalizeRequest, void> {
+    private readonly _dragSession;
+    handle(_request: RotateNodeFinalizeRequest): void;
+    private _isValid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodeFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodeFinalize>;
+}

package/f-draggable/rotate-node/rotate-node-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './rotate-node-handler';

package/f-draggable/rotate-node/rotate-node-handler/rotate-node-handler.d.ts

@@ -0,0 +1,43 @@
+import { IPoint } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { FRotateNodeStartEventData } from '../f-rotate-node-start-event-data';
+import { FNodeBase } from '../../../f-node';
+import { DragNodeConnectionHandlerBase } from '../../drag-node';
+import * as i0 from "@angular/core";
+type TRotateConnectionHandler = {
+    connection: DragNodeConnectionHandlerBase;
+    connector: IPoint;
+};
+export declare class RotateNodeHandler extends DragHandlerBase<FRotateNodeStartEventData> {
+    protected readonly type = "node-rotate";
+    protected readonly kind = "rotate-node";
+    protected data(): FRotateNodeStartEventData;
+    private readonly _store;
+    private readonly _mediator;
+    private readonly _dragSession;
+    private _nodeOrGroup;
+    private _sourceConnections;
+    private _targetConnections;
+    private _startRotation;
+    private _nodeRect;
+    private _nodeCenter;
+    private _pointerDownInFlow;
+    /**
+     * Difference between pointer angle and node rotation at pointer-down.
+     * This lets us keep rotation “locked” to the initial grab angle.
+     */
+    private _rotationOffsetDeg;
+    private get _transform();
+    initialize(nodeOrGroup: FNodeBase, sourceConnections: TRotateConnectionHandler[], targetConnections: TRotateConnectionHandler[]): void;
+    prepareDragSequence(): void;
+    onPointerMove(delta: IPoint): void;
+    onPointerUp(): void;
+    private _readNodeRect;
+    private _calculatePointerDownInFlow;
+    private _angleDeg;
+    private _applyRotation;
+    private _deltaAfterRotation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodeHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodeHandler>;
+}
+export {};

package/f-draggable/rotate-node/rotate-node-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rotate-node-preparation';
+export * from './rotate-node-preparation-request';

package/f-draggable/rotate-node/rotate-node-preparation/rotate-node-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FEventTrigger } from '../../../domain';
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class RotateNodePreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/rotate-node/rotate-node-preparation/rotate-node-preparation.d.ts

@@ -0,0 +1,18 @@
+import { RotateNodePreparationRequest } from './rotate-node-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class RotateNodePreparation implements IExecution<RotateNodePreparationRequest, void> {
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private readonly _dragInjector;
+    private get _transform();
+    handle(request: RotateNodePreparationRequest): void;
+    private _isPreparationAllowed;
+    private _findRotatableNode;
+    private _selectBeforeRotate;
+    private _buildInputConnectionHandlers;
+    private _buildOutputConnectionHandlers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RotateNodePreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RotateNodePreparation>;
+}

package/f-external-item/f-external-item-base.d.ts

@@ -1,14 +1,14 @@
-import { TemplateRef } from '@angular/core';
-import { IHasHostElement } from '../i-has-host-element';
+import { InjectionToken, ModelSignal, Signal, TemplateRef } from '@angular/core';
 import * as i0 from "@angular/core";
-export declare abstract class FExternalItemBase<TData = unknown> implements IHasHostElement {
-    abstract fExternalItemId: string;
-    abstract hostElement: HTMLElement | SVGElement;
-    abstract fData: TData | undefined;
-    abstract fDisabled: boolean;
-    abstract fPreview: TemplateRef<unknown> | undefined;
-    abstract fPreviewMatchSize: boolean;
-    abstract fPlaceholder: TemplateRef<unknown> | undefined;
+export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
+export declare abstract class FExternalItemBase<TData = any> {
+    readonly hostElement: any;
+    abstract externalItemId: Signal<string>;
+    abstract data: Signal<TData | undefined>;
+    abstract disabled: Signal<boolean>;
+    abstract preview: ModelSignal<TemplateRef<unknown> | undefined>;
+    abstract previewMatchSize: Signal<boolean>;
+    abstract placeholder: ModelSignal<TemplateRef<unknown> | undefined>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false, never>;
 }

package/f-external-item/f-external-item-placeholder.d.ts

@@ -0,0 +1,10 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FExternalItemPlaceholder<T = unknown> implements OnInit, OnDestroy {
+    private readonly _instance;
+    private readonly _templateRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPlaceholder<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemPlaceholder<any>, "ng-template[fExternalItemPlaceholder]", never, {}, {}, never, never, true, never>;
+}

package/f-external-item/f-external-item-preview.d.ts

@@ -0,0 +1,10 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FExternalItemPreview<T = unknown> implements OnInit, OnDestroy {
+    private readonly _instance;
+    private readonly _templateRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPreview<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemPreview<any>, "ng-template[fExternalItemPreview]", never, {}, {}, never, never, true, never>;
+}

package/f-external-item/f-external-item.d.ts

@@ -0,0 +1,23 @@
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
+import { FExternalItemBase } from './f-external-item-base';
+import * as i0 from "@angular/core";
+export declare class FExternalItem<TData> extends FExternalItemBase<TData> implements OnInit, OnDestroy {
+    private readonly _apiService;
+    /** Stable id for matching drag sessions, lookups, etc. */
+    readonly externalItemId: import("@angular/core").InputSignal<string>;
+    /** Payload attached to external item. */
+    readonly data: import("@angular/core").InputSignal<TData | undefined>;
+    /** Disables dragging/interaction. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Template shown while item is dragged (preview). */
+    readonly preview: import("@angular/core").ModelSignal<TemplateRef<unknown> | undefined>;
+    /** Whether preview should match original element size. */
+    readonly previewMatchSize: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Placeholder template that stays in original place while dragging. */
+    readonly placeholder: import("@angular/core").ModelSignal<TemplateRef<unknown> | undefined>;
+    ngOnInit(): void;
+    private _disablePointerEvents;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItem<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItem<any>, "[fExternalItem]", never, { "externalItemId": { "alias": "fExternalItemId"; "required": false; "isSignal": true; }; "data": { "alias": "fData"; "required": false; "isSignal": true; }; "disabled": { "alias": "fDisabled"; "required": false; "isSignal": true; }; "preview": { "alias": "fPreview"; "required": false; "isSignal": true; }; "previewMatchSize": { "alias": "fPreviewMatchSize"; "required": false; "isSignal": true; }; "placeholder": { "alias": "fPlaceholder"; "required": false; "isSignal": true; }; }, { "preview": "fPreviewChange"; "placeholder": "fPlaceholderChange"; }, never, never, true, never>;
+}

package/f-external-item/f-external-item.service.d.ts

@@ -1,10 +1,17 @@
 import { FExternalItemBase } from './f-external-item-base';
 import * as i0 from "@angular/core";
 export declare class FExternalItemService {
+    private readonly _byHost;
     private readonly _items;
-    registerItem(item: FExternalItemBase): void;
-    getItem(element: HTMLElement | SVGElement): FExternalItemBase | undefined;
-    removeItem(item: FExternalItemBase): void;
+    /** Reactive list (internal consumers) */
+    readonly items: import("@angular/core").Signal<readonly FExternalItemBase<any>[]>;
+    /** lookup by element (supports passing a nested child) */
+    getByElement(el: HTMLElement | SVGElement): FExternalItemBase | undefined;
+    /** lookup by host */
+    getByHost(host: HTMLElement | SVGElement): FExternalItemBase | undefined;
+    register(item: FExternalItemBase): void;
+    remove(item: FExternalItemBase): void;
+    private _sync;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemService>;
 }

package/f-external-item/index.d.ts

@@ -1,9 +1,7 @@
-export * from './domain';
-export * from './f-external-item.directive';
+export * from './f-external-item';
 export * from './f-external-item.service';
 export * from './f-external-item-base';
-export * from './f-external-item-placeholder.directive';
-export * from './f-external-item-preview.directive';
-export * from './f-external-item-token';
+export * from './f-external-item-placeholder';
+export * from './f-external-item-preview';
 export * from './is-external-item';
 export * from './providers';

package/f-external-item/is-external-item.d.ts

@@ -1,2 +1,2 @@
 export declare function isExternalItem(element: HTMLElement | SVGElement): boolean;
-export declare function getExternalItem(element: HTMLElement | SVGElement): HTMLElement | SVGElement;
+export declare function getExternalItemHost(element: HTMLElement | SVGElement): HTMLElement | SVGElement;

package/f-external-item/providers.d.ts

@@ -1,2 +1,2 @@
-import { FExternalItemDirective } from './f-external-item.directive';
-export declare const F_EXTERNAL_ITEM_PROVIDERS: (typeof FExternalItemDirective)[];
+import { FExternalItem } from './f-external-item';
+export declare const F_EXTERNAL_ITEM_PROVIDERS: (typeof FExternalItem)[];

package/f-flow/f-flow-base.d.ts

@@ -1,8 +1,9 @@
-import { InjectionToken, InputSignal, OutputEmitterRef } from '@angular/core';
+import { InjectionToken, InputSignal, InputSignalWithTransform, OutputEmitterRef } from '@angular/core';
 import { IHasHostElement } from '../i-has-host-element';
 export declare const F_FLOW: InjectionToken<FFlowBase>;
 export declare abstract class FFlowBase implements IHasHostElement {
     abstract fId: InputSignal<string>;
+    abstract fCache: InputSignalWithTransform<boolean, unknown>;
     abstract hostElement: HTMLElement;
     abstract fLoaded: OutputEmitterRef<string>;
 }

package/f-flow/f-flow.component.d.ts

@@ -1,21 +1,25 @@
 import { AfterContentInit, OnDestroy, OnInit } from '@angular/core';
 import { FFlowBase } from './f-flow-base';
-import { IFFlowState, ICurrentSelection } from '../domain';
+import { ICurrentSelection, IFFlowState } from '../domain';
 import { IPoint, IRect } from '@foblex/2d';
 import * as i0 from "@angular/core";
 export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
     private readonly _destroyRef;
     private readonly _mediator;
-    private readonly _browserService;
-    private readonly _elementReference;
+    private readonly _browser;
+    private readonly _cache;
+    private readonly _injector;
+    private readonly _worker;
     fId: import("@angular/core").InputSignal<string>;
-    get hostElement(): HTMLElement;
+    fCache: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly hostElement: any;
     fLoaded: import("@angular/core").OutputEmitterRef<string>;
     private _isLoaded;
     ngOnInit(): void;
     ngAfterContentInit(): void;
-    private _listenCountChanges;
-    private _listenDataChanges;
+    _listenCacheChanges(): void;
+    private _listenNodesChanges;
+    private _listenConnectionsChanges;
     private _emitLoaded;
     redraw(): void;
     reset(): void;
@@ -40,5 +44,5 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     clearSelection(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fId": { "alias": "fFlowId"; "required": false; "isSignal": true; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fId": { "alias": "fFlowId"; "required": false; "isSignal": true; }; "fCache": { "alias": "fCache"; "required": false; "isSignal": true; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "*"], true, never>;
 }