@foblex/flow 17.2.0 → 17.2.1

package/f-draggable/f-draggable-data-context.d.ts

@@ -1,5 +1,5 @@
 import { Point } from '@foblex/2d';
-import { IDraggableItem } from './i-draggable-item';
+import { IFDragHandler } from './f-drag-handler';
 import { ISelectable } from '../mixins';
 import * as i0 from "@angular/core";
 export declare class FDraggableDataContext {
@@ -7,7 +7,7 @@ export declare class FDraggableDataContext {
     isSelectedChanged: boolean;
     onPointerDownScale: number;
     onPointerDownPosition: Point;
-    draggableItems: IDraggableItem[];
+    draggableItems: IFDragHandler[];
     reset(): void;
     markSelectionAsChanged(): void;
     isEmpty(): boolean;

package/f-draggable/f-draggable.directive.d.ts

@@ -1,17 +1,18 @@
 import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from "@angular/core";
 import { FDraggableBase } from './f-draggable-base';
 import { FDropToGroupEvent } from './node';
-import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
+import { FCreateConnectionEvent, FReassignConnectionEvent } from './f-connection';
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FEventTrigger } from '../domain';
 import { FCreateNodeEvent } from '../f-external-item';
 import { BrowserService } from '@foblex/platform';
 import { ICanRunOutsideAngular, IPointerEvent } from '@foblex/drag-toolkit';
-import { FNodeIntersectedWithConnections } from './domain';
+import { FDragStartedEvent, FNodeIntersectedWithConnections } from './domain';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
     private _fBrowser;
     private _elementReference;
+    private _fResult;
     private _fMediator;
     private _fPlatform;
     private _injector;
@@ -30,7 +31,7 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     vCellSize: number;
     hCellSize: number;
     fCellSizeWhileDragging: boolean;
-    fDragStarted: EventEmitter<void>;
+    fDragStarted: EventEmitter<FDragStartedEvent>;
     fDragEnded: EventEmitter<void>;
     private plugins;
     constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);

package/f-draggable/f-selection-change-event.d.ts

@@ -1,7 +1,7 @@
 import { ICurrentSelection } from '../domain';
 export declare class FSelectionChangeEvent implements ICurrentSelection {
-    nodes: string[];
-    groups: string[];
-    connections: string[];
-    constructor(nodes: string[], groups: string[], connections: string[]);
+    fNodeIds: string[];
+    fGroupIds: string[];
+    fConnectionIds: string[];
+    constructor(fNodeIds: string[], fGroupIds: string[], fConnectionIds: string[]);
 }

package/f-draggable/{single-select/single-select.execution.d.ts → f-single-select/f-single-select.execution.d.ts}

@@ -1,5 +1,5 @@
 import { IExecution } from '@foblex/mediator';
-import { SingleSelectRequest } from './single-select.request';
+import { FSingleSelectRequest } from './f-single-select.request';
 import * as i0 from "@angular/core";
 /**
  * Implements the functionality for selecting elements in a graphical interface.
@@ -38,11 +38,11 @@ import * as i0 from "@angular/core";
  *    - Adding or removing an element from the selection triggers the corresponding methods.
  *    - Selection state is tracked in the shared context for future use.
  */
-export declare class SingleSelectExecution implements IExecution<SingleSelectRequest, void> {
+export declare class FSingleSelectExecution implements IExecution<FSingleSelectRequest, void> {
     private _fMediator;
     private _fComponentsStore;
     private _fDraggableDataContext;
-    handle(request: SingleSelectRequest): void;
+    handle(request: FSingleSelectRequest): void;
     private _isValid;
     private _isEventInFlowBounds;
     private _getItemToSelect;
@@ -57,6 +57,6 @@ export declare class SingleSelectExecution implements IExecution<SingleSelectReq
     private _deselectItem;
     private _removeItemFromSelectedItems;
     private _selectItem;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSelectExecution, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SingleSelectExecution>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FSingleSelectExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FSingleSelectExecution>;
 }

package/f-draggable/{single-select/single-select.request.d.ts → f-single-select/f-single-select.request.d.ts}

@@ -1,6 +1,6 @@
 import { IPointerEvent } from '@foblex/drag-toolkit';
 import { FEventTrigger } from '../../domain';
-export declare class SingleSelectRequest {
+export declare class FSingleSelectRequest {
     event: IPointerEvent;
     fMultiSelectTrigger: FEventTrigger;
     constructor(event: IPointerEvent, fMultiSelectTrigger: FEventTrigger);

package/f-draggable/f-single-select/index.d.ts

@@ -0,0 +1,3 @@
+export * from './providers';
+export * from './f-single-select.execution';
+export * from './f-single-select.request';

package/f-draggable/f-single-select/providers.d.ts

@@ -0,0 +1,2 @@
+import { FSingleSelectExecution } from './f-single-select.execution';
+export declare const SINGLE_SELECT_PROVIDERS: (typeof FSingleSelectExecution)[];

package/f-draggable/index.d.ts

@@ -1,15 +1,14 @@
-export * from './canvas';
-export * from './connections';
+export * from './f-canvas';
+export * from './f-drag-handler';
+export * from './f-connection';
 export * from './domain';
-export * from '../domain/f-draggable/is-drag-started';
 export * from './node';
 export * from './node-resize';
-export * from './single-select';
+export * from './f-single-select';
 export * from './f-draggable.directive';
 export * from './f-draggable-base';
 export * from './f-draggable-data-context';
 export * from './f-injector';
 export * from './f-selection-change-event';
 export * from './i-f-drag-and-drop-plugin';
-export * from './i-draggable-item';
 export * from './providers';

package/f-draggable/node/line-alignment.drag-handler.d.ts

@@ -1,12 +1,13 @@
 import { IMinMaxPoint, IPoint, IRect, ISize } from '@foblex/2d';
-import { IDraggableItem } from '../index';
+import { IFDragHandler } from '../index';
 import { ILineAlignmentResult, LineService } from '../../f-line-alignment';
-export declare class LineAlignmentDragHandler implements IDraggableItem {
+export declare class LineAlignmentDragHandler implements IFDragHandler {
     private _lineService;
     private _size;
     private _draggedNodeRect;
     private _rects;
     private _restrictions;
+    fEventType: string;
     private _fComponentsStore;
     private _debounceTimer;
     private readonly _transform;

package/f-draggable/node/node-drag-to-parent.drag-handler.d.ts

@@ -1,13 +1,14 @@
 import { IPoint } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IFDragHandler } from '../f-drag-handler';
 import { FComponentsStore } from '../../f-storage';
 import { INodeWithRect } from '../domain';
 import { FDraggableDataContext } from '../f-draggable-data-context';
 import * as i0 from "@angular/core";
-export declare class NodeDragToParentDragHandler implements IDraggableItem {
+export declare class NodeDragToParentDragHandler implements IFDragHandler {
     private fComponentsStore;
     private fDraggableDataContext;
     private notDraggedNodesRects;
+    fEventType: string;
     private DEBOUNCE_TIME;
     private get _transform();
     private _onPointerDownPosition;

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

@@ -1,11 +1,12 @@
 import { IPoint } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IFDragHandler } from '../f-drag-handler';
 import { FNodeBase } from '../../f-node';
 import { BaseConnectionDragHandler } from './connection-drag-handlers';
-export declare class NodeDragHandler implements IDraggableItem {
+export declare class NodeDragHandler implements IFDragHandler {
     fNode: FNodeBase;
     fSourceHandlers: BaseConnectionDragHandler[];
     fTargetHandlers: BaseConnectionDragHandler[];
+    fEventType: string;
     private readonly _onPointerDownPosition;
     constructor(fNode: FNodeBase, fSourceHandlers?: BaseConnectionDragHandler[], fTargetHandlers?: BaseConnectionDragHandler[]);
     onPointerMove(difference: IPoint): void;

package/f-draggable/node/summary-node.drag-handler.d.ts

@@ -1,10 +1,12 @@
 import { IMinMaxPoint, IPoint, IRect } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IFDragHandler } from '../f-drag-handler';
 import { NodeDragHandler } from './node.drag-handler';
-export declare class SummaryNodeDragHandler implements IDraggableItem {
+export declare class SummaryNodeDragHandler implements IFDragHandler {
     limits: IMinMaxPoint;
     fHandlers: NodeDragHandler[];
     commonRect: IRect;
+    fEventType: string;
+    fData: any;
     private _fComponentStore;
     private readonly _fBoundsLimiter;
     constructor(limits: IMinMaxPoint, fHandlers: NodeDragHandler[], commonRect: IRect);

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

@@ -1,9 +1,11 @@
 import { IPoint } from '@foblex/2d';
-import { IDraggableItem } from '../i-draggable-item';
+import { IFDragHandler } from '../f-drag-handler/i-f-drag-handler';
 import { EFResizeHandleType, FNodeBase } from '../../f-node';
-export declare class NodeResizeDragHandler implements IDraggableItem {
+export declare class NodeResizeDragHandler implements IFDragHandler {
     private _fNode;
     private _fResizeHandleType;
+    fEventType: string;
+    fData: any;
     private _fMediator;
     private _originalRect;
     private _resizeRestrictions;

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node").CalculateCommonNodeMoveLimitsExecution | typeof import("./node").CalculateNodeMoveLimitsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").LineAlignmentPreparationExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionDragHandlerPreparationExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./single-select").SingleSelectExecution | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./f-canvas").FCanvasMoveFinalizeExecution | typeof import("./f-canvas").FCanvasMovePreparationExecution | typeof import("./f-connection").FCreateConnectionFinalizeExecution | typeof import("./f-connection").FCreateConnectionDragHandlerPreparationExecution | typeof import("./f-connection").FCreateConnectionFromOutletPreparationExecution | typeof import("./f-connection").GetFirstConnectableOutputExecution | typeof import("./f-connection").FCreateConnectionFromOutputPreparationExecution | typeof import("./f-connection").FCreateConnectionPreparationExecution | typeof import("./f-connection").FReassignConnectionFinalizeExecution | typeof import("./f-connection").FReassignConnectionPreparationExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./domain").IsConnectionUnderNodeExecution | typeof import("./f-single-select").FSingleSelectExecution | typeof import("../f-external-item").FExternalItemCreatePlaceholderExecution | typeof import("../f-external-item").FExternalItemCreatePreviewExecution | typeof import("../f-external-item").FExternalItemFinalizeExecution | typeof import("../f-external-item").FExternalItemPreparationExecution | typeof import("../f-external-item").PreventDefaultIsExternalItemExecution | typeof import("./node").CalculateCommonNodeMoveLimitsExecution | typeof import("./node").CalculateNodeMoveLimitsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").LineAlignmentPreparationExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeDragToParentPreparationExecution | typeof import("./node").NodeDragToParentFinalizeExecution | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("@foblex/flow").CalculateFlowPointFromMinimapPointExecution | typeof import("@foblex/flow").MinimapDragFinalizeExecution | typeof import("@foblex/flow").MinimapDragPreparationExecution | typeof import("@foblex/flow").MinimapDrawNodesExecution | typeof import("@foblex/flow").MinimapCalculateSvgScaleAndViewBoxExecution | typeof import("@foblex/flow").MinimapCalculateViewBoxExecution)[];

package/f-external-item/domain/create-placeholder/f-external-item-create-placeholder.execution.d.ts

@@ -0,0 +1,13 @@
+import { FExternalItemCreatePlaceholderRequest } from './f-external-item-create-placeholder.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FExternalItemCreatePlaceholderExecution implements IExecution<FExternalItemCreatePlaceholderRequest, HTMLElement | SVGElement> {
+    private _fBrowser;
+    private _containerRef;
+    handle(request: FExternalItemCreatePlaceholderRequest): HTMLElement | SVGElement;
+    private _fromTemplate;
+    private _fromHost;
+    private _createViewRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemCreatePlaceholderExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemCreatePlaceholderExecution>;
+}

package/f-external-item/domain/create-placeholder/f-external-item-create-placeholder.request.d.ts

@@ -0,0 +1,5 @@
+import { FExternalItemBase } from '../../f-external-item-base';
+export declare class FExternalItemCreatePlaceholderRequest {
+    fExternalItem: FExternalItemBase;
+    constructor(fExternalItem: FExternalItemBase);
+}

package/f-external-item/domain/create-placeholder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-external-item-create-placeholder.execution';
+export * from './f-external-item-create-placeholder.request';

package/f-external-item/domain/create-preview/f-external-item-create-preview.execution.d.ts

@@ -0,0 +1,14 @@
+import { FExternalItemCreatePreviewRequest } from './f-external-item-create-preview.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FExternalItemCreatePreviewExecution implements IExecution<FExternalItemCreatePreviewRequest, HTMLElement | SVGElement> {
+    private _fBrowser;
+    private _containerRef;
+    handle(request: FExternalItemCreatePreviewRequest): HTMLElement | SVGElement;
+    private _fromTemplate;
+    private _fromHost;
+    private _createViewRef;
+    private _setPreviewStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemCreatePreviewExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemCreatePreviewExecution>;
+}

package/f-external-item/domain/create-preview/f-external-item-create-preview.request.d.ts

@@ -0,0 +1,5 @@
+import { FExternalItemBase } from '../../f-external-item-base';
+export declare class FExternalItemCreatePreviewRequest {
+    fExternalItem: FExternalItemBase;
+    constructor(fExternalItem: FExternalItemBase);
+}

package/f-external-item/domain/create-preview/index.d.ts

@@ -0,0 +1,2 @@
+export * from './f-external-item-create-preview.execution';
+export * from './f-external-item-create-preview.request';

package/f-external-item/domain/f-external-item.drag-handler.d.ts

@@ -0,0 +1,24 @@
+import { IPoint } from '@foblex/2d';
+import { FExternalItemBase } from '../../f-external-item';
+import { IFDragHandler } from '../../f-draggable';
+export declare class FExternalItemDragHandler implements IFDragHandler {
+    private _fExternalItem;
+    fEventType: string;
+    fData: any;
+    private _fResult;
+    private _fMediator;
+    private _fBrowser;
+    private _preview;
+    private _placeholder;
+    private _onPointerDownRect;
+    private get _fItemHost();
+    constructor(_fExternalItem: FExternalItemBase);
+    prepareDragSequence(): void;
+    private _createAndAppendPreview;
+    private _createAndAppendPlaceholder;
+    private _matchElementSize;
+    private _setFResultData;
+    private _getExternalItemRect;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
+}

package/f-external-item/domain/finalize/f-external-item-finalize.execution.d.ts

@@ -0,0 +1,21 @@
+import { FExternalItemFinalizeRequest } from './f-external-item-finalize.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FExternalItemFinalizeExecution implements IExecution<FExternalItemFinalizeRequest, void> {
+    private _fResult;
+    private _fMediator;
+    private _fComponentsStore;
+    private _fDraggableDataContext;
+    private _fBrowser;
+    private get _fHost();
+    private get _fCreateNode();
+    private get _fDragHandler();
+    handle(request: FExternalItemFinalizeRequest): void;
+    private _isValid;
+    private _getElementsFromPoint;
+    private _emitEvent;
+    private isPointerInCanvasRect;
+    private _getPreviewRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemFinalizeExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemFinalizeExecution>;
+}

package/{f-draggable/canvas/canvas-move-preparation/canvas-move-preparation.request.d.ts → f-external-item/domain/finalize/f-external-item-finalize.request.d.ts}

@@ -1,5 +1,5 @@
 import { IPointerEvent } from '@foblex/drag-toolkit';
-export declare class CanvasMovePreparationRequest {
+export declare class FExternalItemFinalizeRequest {
     event: IPointerEvent;
     constructor(event: IPointerEvent);
 }

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

@@ -0,0 +1,2 @@
+export * from './f-external-item-finalize.execution';
+export * from './f-external-item-finalize.request';

package/f-external-item/domain/i-f-external-item-drag-result.d.ts

@@ -0,0 +1,5 @@
+import { FExternalItemBase } from '../f-external-item-base';
+export interface IFExternalItemDragResult {
+    preview: HTMLElement | SVGElement;
+    fExternalItem: FExternalItemBase;
+}

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

@@ -1,6 +1,9 @@
-export * from './external-item-finalize';
-export * from './external-item-preparation';
+export * from './create-placeholder';
+export * from './create-preview';
+export * from './finalize';
+export * from './preparation';
 export * from './f-create-node.event';
 export * from './prevent-default-is-external-item';
-export * from './external-item.drag-handler';
+export * from './f-external-item.drag-handler';
+export * from './i-f-external-item-drag-result';
 export * from './providers';

package/f-external-item/domain/preparation/f-external-item-preparation.execution.d.ts

@@ -0,0 +1,15 @@
+import { FExternalItemPreparationRequest } from './f-external-item-preparation.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class FExternalItemPreparationExecution implements IExecution<FExternalItemPreparationRequest, void> {
+    private _fExternalItemService;
+    private _fDraggableDataContext;
+    private _fComponentsStore;
+    private get _fHost();
+    handle(request: FExternalItemPreparationRequest): void;
+    private _isValid;
+    private _isValidExternalItem;
+    private _getExternalItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemPreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FExternalItemPreparationExecution>;
+}

package/{f-draggable/connections/create-connection/create-connection-finalize/create-connection-finalize.request.d.ts → f-external-item/domain/preparation/f-external-item-preparation.request.d.ts}

@@ -1,5 +1,5 @@
 import { IPointerEvent } from '@foblex/drag-toolkit';
-export declare class CreateConnectionFinalizeRequest {
+export declare class FExternalItemPreparationRequest {
     event: IPointerEvent;
     constructor(event: IPointerEvent);
 }

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

@@ -0,0 +1,2 @@
+export * from './f-external-item-preparation.execution';
+export * from './f-external-item-preparation.request';

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

@@ -1,2 +1,6 @@
+import { FExternalItemPreparationExecution } from './preparation';
+import { FExternalItemFinalizeExecution } from './finalize';
 import { PreventDefaultIsExternalItemExecution } from './prevent-default-is-external-item';
-export declare const F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS: (typeof import("./external-item-preparation").ExternalItemPreparationExecution | typeof import("./external-item-finalize").ExternalItemFinalizeExecution | typeof PreventDefaultIsExternalItemExecution)[];
+import { FExternalItemCreatePreviewExecution } from './create-preview';
+import { FExternalItemCreatePlaceholderExecution } from './create-placeholder';
+export declare const F_EXTERNAL_ITEM_DRAG_AND_DROP_PROVIDERS: (typeof FExternalItemCreatePlaceholderExecution | typeof FExternalItemCreatePreviewExecution | typeof FExternalItemFinalizeExecution | typeof FExternalItemPreparationExecution | typeof PreventDefaultIsExternalItemExecution)[];

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

@@ -1,12 +1,14 @@
-import { InjectionToken } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
-export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;
 export declare abstract class FExternalItemBase<TData = any> implements IHasHostElement {
     abstract fExternalItemId: string;
     abstract hostElement: HTMLElement | SVGElement;
     abstract fData: TData | undefined;
     abstract fDisabled: boolean;
+    abstract fPreview: TemplateRef<any> | undefined;
+    abstract fPreviewMatchSize: boolean;
+    abstract fPlaceholder: TemplateRef<any> | 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.directive.d.ts

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

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

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

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

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { FExternalItemBase } from './f-external-item-base';
+export declare const F_EXTERNAL_ITEM: InjectionToken<FExternalItemBase<any>>;

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

@@ -1,18 +1,21 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OnDestroy, OnInit, TemplateRef } from '@angular/core';
 import { FExternalItemBase } from './f-external-item-base';
-import { FExternalItemService } from './f-external-item.service';
 import * as i0 from "@angular/core";
 export declare class FExternalItemDirective<TData> extends FExternalItemBase<TData> implements OnInit, OnDestroy {
-    private elementReference;
-    private fExternalItemService;
+    private _elementReference;
+    private _fExternalItemService;
     fExternalItemId: string;
     get hostElement(): HTMLElement | SVGElement;
     fData: TData | undefined;
     fDisabled: boolean;
-    constructor(elementReference: ElementRef<HTMLElement>, fExternalItemService: FExternalItemService);
+    fPreview: TemplateRef<any> | undefined;
+    fPreviewMatchSize: boolean;
+    fPlaceholder: TemplateRef<any> | undefined;
     ngOnInit(): void;
     private disablePointerEvents;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": { "alias": "fExternalItemId"; "required": false; }; "fData": { "alias": "fData"; "required": false; }; "fDisabled": { "alias": "fDisabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": { "alias": "fExternalItemId"; "required": false; }; "fData": { "alias": "fData"; "required": false; }; "fDisabled": { "alias": "fDisabled"; "required": false; }; "fPreview": { "alias": "fPreview"; "required": false; }; "fPreviewMatchSize": { "alias": "fPreviewMatchSize"; "required": false; }; "fPlaceholder": { "alias": "fPlaceholder"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_fDisabled: unknown;
+    static ngAcceptInputType_fPreviewMatchSize: unknown;
 }

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

@@ -1,7 +1,7 @@
 import { FExternalItemBase } from './f-external-item-base';
 import * as i0 from "@angular/core";
 export declare class FExternalItemService {
-    private items;
+    private _items;
     registerItem(item: FExternalItemBase): void;
     getItem(element: HTMLElement | SVGElement): FExternalItemBase | undefined;
     removeItem(item: FExternalItemBase): void;

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

@@ -1,6 +1,8 @@
 export * from './domain';
-export * from './f-external-item-base';
-export * from './is-external-item';
 export * from './f-external-item.directive';
 export * from './f-external-item.service';
-export * from './providers';
+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 './is-external-item';

package/f-flow.module.d.ts

@@ -18,22 +18,21 @@ import * as i16 from "./f-connection/f-snap-connection/f-snap-connection.compone
 import * as i17 from "./f-connectors/f-node-input/f-node-input.directive";
 import * as i18 from "./f-connectors/f-node-outlet/f-node-outlet.directive";
 import * as i19 from "./f-connectors/f-node-output/f-node-output.directive";
-import * as i20 from "./f-external-item/f-external-item.directive";
-import * as i21 from "./f-flow/f-flow.component";
-import * as i22 from "./f-line-alignment/f-line-alignment.component";
-import * as i23 from "./f-minimap/f-minimap.component";
-import * as i24 from "./f-minimap/f-minimap-canvas.directive";
-import * as i25 from "./f-minimap/f-minimap-view.directive";
-import * as i26 from "./f-minimap/f-minimap-flow.directive";
-import * as i27 from "./f-node/f-group.directive";
-import * as i28 from "./f-node/f-node.directive";
-import * as i29 from "./f-node/f-drag-handle.directive";
-import * as i30 from "./f-node/f-resize-handle/f-resize-handle.directive";
-import * as i31 from "./f-selection-area/f-selection-area.component";
-import * as i32 from "./f-draggable/f-draggable.directive";
-import * as i33 from "@angular/common";
+import * as i20 from "./f-flow/f-flow.component";
+import * as i21 from "./f-line-alignment/f-line-alignment.component";
+import * as i22 from "./f-minimap/f-minimap.component";
+import * as i23 from "./f-minimap/f-minimap-canvas.directive";
+import * as i24 from "./f-minimap/f-minimap-view.directive";
+import * as i25 from "./f-minimap/f-minimap-flow.directive";
+import * as i26 from "./f-node/f-group.directive";
+import * as i27 from "./f-node/f-node.directive";
+import * as i28 from "./f-node/f-drag-handle.directive";
+import * as i29 from "./f-node/f-resize-handle/f-resize-handle.directive";
+import * as i30 from "./f-selection-area/f-selection-area.component";
+import * as i31 from "./f-draggable/f-draggable.directive";
+import * as i32 from "@angular/common";
 export declare class FFlowModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FFlowModule, [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FSnapConnectionComponent, typeof i17.FNodeInputDirective, typeof i18.FNodeOutletDirective, typeof i19.FNodeOutputDirective, typeof i20.FExternalItemDirective, typeof i21.FFlowComponent, typeof i22.FLineAlignmentComponent, typeof i23.FMinimapComponent, typeof i24.FMinimapCanvasDirective, typeof i25.FMinimapViewDirective, typeof i26.FMinimapFlowDirective, typeof i27.FGroupDirective, typeof i28.FNodeDirective, typeof i29.FDragHandleDirective, typeof i30.FResizeHandleDirective, typeof i31.FSelectionAreaComponent, typeof i32.FDraggableDirective], [typeof i33.CommonModule], [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FSnapConnectionComponent, typeof i17.FNodeInputDirective, typeof i18.FNodeOutletDirective, typeof i19.FNodeOutputDirective, typeof i20.FExternalItemDirective, typeof i21.FFlowComponent, typeof i22.FLineAlignmentComponent, typeof i23.FMinimapComponent, typeof i24.FMinimapCanvasDirective, typeof i25.FMinimapViewDirective, typeof i26.FMinimapFlowDirective, typeof i27.FGroupDirective, typeof i28.FNodeDirective, typeof i29.FDragHandleDirective, typeof i30.FResizeHandleDirective, typeof i31.FSelectionAreaComponent, typeof i32.FDraggableDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FFlowModule, [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FSnapConnectionComponent, typeof i17.FNodeInputDirective, typeof i18.FNodeOutletDirective, typeof i19.FNodeOutputDirective, typeof i20.FFlowComponent, typeof i21.FLineAlignmentComponent, typeof i22.FMinimapComponent, typeof i23.FMinimapCanvasDirective, typeof i24.FMinimapViewDirective, typeof i25.FMinimapFlowDirective, typeof i26.FGroupDirective, typeof i27.FNodeDirective, typeof i28.FDragHandleDirective, typeof i29.FResizeHandleDirective, typeof i30.FSelectionAreaComponent, typeof i31.FDraggableDirective], [typeof i32.CommonModule], [typeof i1.FBackgroundComponent, typeof i2.FRectPatternComponent, typeof i3.FCirclePatternComponent, typeof i4.FCanvasComponent, typeof i5.FZoomDirective, typeof i6.FConnectionTextComponent, typeof i7.FConnectionTextPathDirective, typeof i8.FConnectionDragHandleComponent, typeof i9.FConnectionGradientComponent, typeof i10.FConnectionPathComponent, typeof i11.FConnectionSelectionComponent, typeof i12.FConnectionComponent, typeof i13.FConnectionCenterDirective, typeof i14.FConnectionForCreateComponent, typeof i15.FMarkerDirective, typeof i16.FSnapConnectionComponent, typeof i17.FNodeInputDirective, typeof i18.FNodeOutletDirective, typeof i19.FNodeOutputDirective, typeof i20.FFlowComponent, typeof i21.FLineAlignmentComponent, typeof i22.FMinimapComponent, typeof i23.FMinimapCanvasDirective, typeof i24.FMinimapViewDirective, typeof i25.FMinimapFlowDirective, typeof i26.FGroupDirective, typeof i27.FNodeDirective, typeof i28.FDragHandleDirective, typeof i29.FResizeHandleDirective, typeof i30.FSelectionAreaComponent, typeof i31.FDraggableDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<FFlowModule>;
 }

package/f-minimap/domain/f-minimap.drag-handler.d.ts

@@ -1,15 +1,16 @@
 import { IPoint, IRect } from '@foblex/2d';
 import { FComponentsStore } from '../../f-storage';
-import { IDraggableItem } from '../../f-draggable';
+import { IFDragHandler } from '../../f-draggable';
 import { FMediator } from '@foblex/mediator';
 import { FMinimapData } from './f-minimap-data';
-export declare class FMinimapDragHandler implements IDraggableItem {
+export declare class FMinimapDragHandler implements IFDragHandler {
     private fComponentsStore;
     private fMediator;
     private flowRect;
     private canvasPosition;
     private eventPoint;
     private minimap;
+    fEventType: string;
     private lastDifference;
     constructor(fComponentsStore: FComponentsStore, fMediator: FMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
     prepareDragSequence(): void;

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

@@ -2,4 +2,4 @@ import { CalculateFlowPointFromMinimapPointExecution } from './calculate-flow-po
 import { MinimapDrawNodesExecution } from './minimap-draw-nodes';
 import { MinimapCalculateViewBoxExecution } from './minimap-calculate-view-box';
 import { MinimapCalculateSvgScaleAndViewBoxExecution } from './minimap-calculate-svg-scale-and-view-box';
-export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof CalculateFlowPointFromMinimapPointExecution | typeof MinimapDrawNodesExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution | typeof MinimapCalculateViewBoxExecution)[];
+export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPointExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof MinimapDrawNodesExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution | typeof MinimapCalculateViewBoxExecution)[];

package/f-node/providers.d.ts

@@ -2,4 +2,4 @@ import { FNodeDirective } from './f-node.directive';
 import { FResizeHandleDirective } from './f-resize-handle';
 import { FGroupDirective } from './f-group.directive';
 import { FDragHandleDirective } from './f-drag-handle.directive';
-export declare const F_NODE_PROVIDERS: (typeof FResizeHandleDirective | typeof FNodeDirective | typeof FGroupDirective | typeof FDragHandleDirective)[];
+export declare const F_NODE_PROVIDERS: (typeof FGroupDirective | typeof FNodeDirective | typeof FDragHandleDirective | typeof FResizeHandleDirective)[];

package/f-selection-area/domain/selection-area.drag-handle.d.ts

@@ -1,13 +1,14 @@
 import { IPoint } from '@foblex/2d';
 import { FComponentsStore } from '../../f-storage';
 import { FMediator } from '@foblex/mediator';
-import { FDraggableDataContext, IDraggableItem } from '../../f-draggable';
+import { FDraggableDataContext, IFDragHandler } from '../../f-draggable';
 import { FSelectionAreaBase } from '../f-selection-area-base';
-export declare class SelectionAreaDragHandle implements IDraggableItem {
+export declare class SelectionAreaDragHandle implements IFDragHandler {
     private _fComponentsStore;
     private _fSelectionArea;
     private _fDraggableDataContext;
     private _fMediator;
+    fEventType: string;
     private _canBeSelected;
     private _selectedByMove;
     private get _fCanvasPosition();