@foblex/flow 16.0.5 → 17.0.1

package/f-connection/f-marker/f-marker.directive.d.ts

@@ -1,9 +1,7 @@
 import { ElementRef, OnDestroy, OnInit } from "@angular/core";
 import { FMarkerBase } from './f-marker-base';
-import { FComponentsStore } from '../../f-storage';
 import * as i0 from "@angular/core";
 export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnDestroy {
-    private fComponentsStore;
     private elementReference;
     get hostElement(): HTMLElement;
     width: number;
@@ -13,7 +11,8 @@ export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnD
     type: string;
     orient: 'auto' | 'auto-start-reverse' | 'calculated' | string;
     markerUnits: 'strokeWidth' | 'userSpaceOnUse';
-    constructor(fComponentsStore: FComponentsStore, elementReference: ElementRef<HTMLElement>);
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerDirective, never>;

package/f-connection/f-snap-connection/f-snap-connection.component.d.ts

@@ -1,37 +1,24 @@
-import { AfterViewInit, ElementRef, OnDestroy, OnInit, QueryList } from "@angular/core";
+import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit, QueryList } from "@angular/core";
 import { FConnectionDragHandleComponent, FConnectionSelectionComponent, IConnectionGradient, IConnectionPath, IConnectionText } from '../common';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
 import { FConnectionCenterDirective } from '../f-connection-center';
 import { FConnectionFactory } from '../f-connection-builder';
-import { FComponentsStore } from '../../f-storage';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
-export declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnDestroy {
-    private fComponentsStore;
+export declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
     fId: string;
     fText: string;
-    private _fStartColor;
-    set fStartColor(value: string);
-    get fStartColor(): string;
-    private _fEndColor;
-    set fEndColor(value: string);
-    get fEndColor(): string;
+    fTextStartOffset: string;
+    fStartColor: string;
+    fEndColor: string;
     fSnapThreshold: number;
     fOutputId: string;
     fInputId: string;
-    private _fRadius;
-    set fRadius(value: number);
-    get fRadius(): number;
-    private _fOffset;
-    set fOffset(value: number);
-    get fOffset(): number;
-    private _behavior;
-    set fBehavior(value: EFConnectionBehavior | string);
-    get fBehavior(): EFConnectionBehavior;
-    private _type;
-    set fType(value: EFConnectionType | string);
-    get fType(): EFConnectionType;
+    fRadius: number;
+    fOffset: number;
+    fBehavior: EFConnectionBehavior;
+    fType: EFConnectionType | string;
     fDraggingDisabled: boolean;
     fSelectionDisabled: boolean;
     fDefs: ElementRef<SVGDefsElement>;
@@ -43,10 +30,13 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     fConnectionCenter: ElementRef<HTMLDivElement>;
     fConnectionCenters: QueryList<FConnectionCenterDirective>;
     get boundingElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory, fComponentsStore: FComponentsStore);
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
+    ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
+    static ngAcceptInputType_fBehavior: unknown;
 }

package/f-connection/providers.d.ts

@@ -4,4 +4,4 @@ import { FConnectionCenterDirective } from './f-connection-center';
 import { FConnectionForCreateComponent } from './f-connection-for-create';
 import { FMarkerDirective } from './f-marker';
 import { FSnapConnectionComponent } from './f-snap-connection';
-export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FConnectionDragHandleComponent | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionSelectionComponent | typeof FMarkerDirective | typeof FConnectionCenterDirective | typeof FConnectionForCreateComponent | typeof FConnectionComponent | typeof FSnapConnectionComponent)[];
+export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FConnectionDragHandleComponent | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionSelectionComponent | typeof FConnectionCenterDirective | typeof FConnectionForCreateComponent | typeof FConnectionComponent | typeof FMarkerDirective | typeof FSnapConnectionComponent)[];

package/f-connectors/f-connector-base.d.ts

@@ -1,17 +1,16 @@
-import { Subject } from 'rxjs';
 import { EFConnectableSide } from './e-f-connectable-side';
-import { IHasStateChanges } from '../i-has-state-changes';
 import { IHasHostElement } from '../i-has-host-element';
-export declare abstract class FConnectorBase implements IHasStateChanges, IHasHostElement {
-    abstract id: string;
+export declare abstract class FConnectorBase implements IHasHostElement {
+    abstract fId: string;
     abstract disabled: boolean;
     abstract hostElement: HTMLElement | SVGElement;
-    readonly stateChanges: Subject<void>;
     abstract canBeConnected: boolean;
-    abstract isConnected: boolean;
+    private _isConnected;
+    get isConnected(): boolean;
+    toConnector: FConnectorBase | undefined;
     isSelfConnectable: boolean;
     fConnectableSide: EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
+    userFConnectableSide: EFConnectableSide;
     isContains(element: HTMLElement | SVGElement): boolean;
-    setConnected(isConnected: boolean): void;
+    setConnected(isConnected: boolean, toConnector?: FConnectorBase): void;
 }

package/f-connectors/f-node-input/f-node-input-base.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
 export declare abstract class FNodeInputBase extends FConnectorBase {
     abstract multiple: boolean;
-    isConnected: boolean;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, never, never, false, never>;

package/f-connectors/f-node-input/f-node-input.directive.d.ts

@@ -1,27 +1,25 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { FNodeInputBase } from './f-node-input-base';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
+import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
-export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnDestroy {
-    private elementReference;
+export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnChanges, OnDestroy {
     private fNode;
-    private fComponentsStore;
-    id: any;
+    fId: any;
     multiple: boolean;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
-    set _fSide(value: EFConnectableSide | string);
-    get _fSide(): EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
-    isConnected: boolean;
+    disabled: boolean;
+    userFConnectableSide: EFConnectableSide;
     get hostElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
+    private _elementReference;
+    private _fMediator;
+    constructor(fNode: FNodeBase);
     ngOnInit(): void;
-    setConnected(isConnected: boolean): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setConnected(isConnected: boolean, toConnector?: FConnectorBase): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "id": { "alias": "fInputId"; "required": false; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "_fSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "fId": { "alias": "fInputId"; "required": false; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_userFConnectableSide: unknown;
 }

package/f-connectors/f-node-outlet/f-node-outlet-base.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
 export declare abstract class FNodeOutletBase extends FConnectorBase {
     abstract isConnectionFromOutlet: boolean;
-    isConnected: boolean;
     private outputs;
     get canBeConnected(): boolean;
     setOutputs(outputs: FConnectorBase[]): void;

package/f-connectors/f-node-outlet/f-node-outlet.directive.d.ts

@@ -1,24 +1,22 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OnDestroy, OnInit } from '@angular/core';
 import { FNodeOutletBase } from './f-node-outlet-base';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import * as i0 from "@angular/core";
 export declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
-    private elementReference;
     private fNode;
-    private fComponentsStore;
-    id: string;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
+    fId: string;
+    disabled: boolean;
     fConnectableSide: EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
+    userFConnectableSide: EFConnectableSide;
     isConnectionFromOutlet: boolean;
     get hostElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
+    private _elementReference;
+    private _fMediator;
+    constructor(fNode: FNodeBase);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "id": { "alias": "fOutletId"; "required": false; }; "disabled": { "alias": "fOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "fId": { "alias": "fOutletId"; "required": false; }; "disabled": { "alias": "fOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
 }

package/f-connectors/f-node-output/f-node-output-base.d.ts

@@ -4,7 +4,6 @@ import * as i0 from "@angular/core";
 export declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
 export declare abstract class FNodeOutputBase extends FConnectorBase {
     abstract multiple: boolean;
-    isConnected: boolean;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, false, never>;

package/f-connectors/f-node-output/f-node-output.directive.d.ts

@@ -1,28 +1,26 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { FNodeOutputBase } from './f-node-output-base';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import { FNodeBase } from '../../f-node';
-import { FComponentsStore } from '../../f-storage';
+import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
-export declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnDestroy {
-    private elementReference;
+export declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnChanges, OnDestroy {
     private fNode;
-    private fComponentsStore;
-    id: string;
+    fId: string;
     multiple: boolean;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
-    set _fSide(value: EFConnectableSide | string);
-    get _fSide(): EFConnectableSide;
-    _fConnectableSide: EFConnectableSide;
-    isConnected: boolean;
+    disabled: boolean;
+    userFConnectableSide: EFConnectableSide;
     isSelfConnectable: boolean;
     get hostElement(): HTMLElement | SVGElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fNode: FNodeBase, fComponentsStore: FComponentsStore);
+    private _elementReference;
+    private _fMediator;
+    constructor(fNode: FNodeBase);
     ngOnInit(): void;
-    setConnected(isConnected: boolean): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setConnected(isConnected: boolean, toConnector?: FConnectorBase): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "id": { "alias": "fOutputId"; "required": false; }; "multiple": { "alias": "fOutputMultiple"; "required": false; }; "disabled": { "alias": "fOutputDisabled"; "required": false; }; "_fSide": { "alias": "fOutputConnectableSide"; "required": false; }; "isSelfConnectable": { "alias": "isSelfConnectable"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "fId": { "alias": "fOutputId"; "required": false; }; "multiple": { "alias": "fOutputMultiple"; "required": false; }; "disabled": { "alias": "fOutputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fOutputConnectableSide"; "required": false; }; "isSelfConnectable": { "alias": "isSelfConnectable"; "required": false; }; }, {}, never, never, false, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_userFConnectableSide: unknown;
 }

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

@@ -5,7 +5,7 @@ export declare class CanvasDragHandler implements IDraggableItem {
     private fComponentsStore;
     private onPointerDownPosition;
     constructor(fComponentsStore: FComponentsStore);
-    initialize(): void;
-    move(difference: IPoint): void;
-    complete(): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
 }

package/f-draggable/connections/create-connection/create-connection.drag-handler.d.ts

@@ -16,10 +16,10 @@ export declare class CreateConnectionDragHandler implements IDraggableItem {
     private fOutputWithRect;
     private canBeConnectedInputs;
     constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, fOutput: FConnectorBase, onPointerDownPosition: IPoint);
-    initialize(): void;
-    move(difference: IPoint): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
     private drawTempConnection;
     private drawSnapConnection;
     getClosetInput(difference: IPoint): IConnectorWithRect | undefined;
-    complete(): void;
+    onPointerUp(): void;
 }

package/f-draggable/connections/reassign-connection/reassign-connection.drag-handler.d.ts

@@ -14,12 +14,12 @@ export declare class ReassignConnectionDragHandler implements IDraggableItem {
     private fInputWithRect;
     private canBeConnectedInputs;
     constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, fConnection: FConnectionBase);
-    initialize(): void;
+    prepareDragSequence(): void;
     private getOutput;
     private getInput;
-    move(difference: IPoint): void;
+    onPointerMove(difference: IPoint): void;
     private drawConnection;
     private drawSnapConnection;
     getClosetInput(difference: IPoint): IConnectorWithRect | undefined;
-    complete(): void;
+    onPointerUp(): void;
 }

package/f-draggable/domain/i-node-with-rect.d.ts

@@ -0,0 +1,6 @@
+import { IRect } from '@foblex/2d';
+import { FNodeBase } from '../../f-node';
+export interface INodeWithRect {
+    node: FNodeBase;
+    rect: IRect;
+}

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

@@ -3,4 +3,5 @@ export * from './get-normalized-node-rect';
 export * from './get-normalized-parent-node-rect';
 export * from './get-parent-nodes';
 export * from './is-array-has-parent-node';
+export * from './i-node-with-rect';
 export * from './providers';

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

@@ -3,12 +3,14 @@ import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections'
 import { FSelectionChangeEvent } from './f-selection-change-event';
 import { FCreateNodeEvent } from '../f-external-item';
 import { DragAndDropBase, ICanRunOutsideAngular } from '@foblex/drag-toolkit';
+import { FDropToGroupEvent } from './node';
 import * as i0 from "@angular/core";
 export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     abstract fCreateNode: EventEmitter<FCreateNodeEvent>;
     abstract fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
+    abstract fDropToGroup: EventEmitter<FDropToGroupEvent>;
     protected constructor(ngZone: ICanRunOutsideAngular | undefined);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;

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

@@ -1,41 +1,34 @@
-import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, EventEmitter, OnDestroy, OnInit } from "@angular/core";
 import { FDraggableBase } from './f-draggable-base';
-import { FComponentsStore } from '../f-storage';
-import { FDraggableDataContext } from './f-draggable-data-context';
+import { FDropToGroupEvent } from './node';
 import { FCreateConnectionEvent, FReassignConnectionEvent } from './connections';
 import { FSelectionChangeEvent } from './f-selection-change-event';
-import { FMediator } from '@foblex/mediator';
 import { FCreateNodeEvent } from '../f-external-item';
 import { BrowserService } from '@foblex/platform';
 import { ICanRunOutsideAngular, IPointerEvent } from '@foblex/drag-toolkit';
 import * as i0 from "@angular/core";
 export declare class FDraggableDirective extends FDraggableBase implements OnInit, AfterViewInit, OnDestroy {
-    private elementReference;
-    private fDraggableDataContext;
-    private fComponentsStore;
-    private fMediator;
-    private fBrowser;
-    private subscriptions$;
+    private _fBrowser;
+    private _elementReference;
+    private _fMediator;
     disabled: boolean;
     get hostElement(): HTMLElement;
     fSelectionChange: EventEmitter<FSelectionChangeEvent>;
     fCreateNode: EventEmitter<FCreateNodeEvent>;
     fReassignConnection: EventEmitter<FReassignConnectionEvent>;
     fCreateConnection: EventEmitter<FCreateConnectionEvent>;
+    fDropToGroup: EventEmitter<FDropToGroupEvent>;
     private plugins;
-    constructor(elementReference: ElementRef<HTMLElement>, fDraggableDataContext: FDraggableDataContext, ngZone: ICanRunOutsideAngular, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
+    constructor(ngZone: ICanRunOutsideAngular, _fBrowser: BrowserService);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     onPointerDown(event: IPointerEvent): boolean;
     protected prepareDragSequence(event: IPointerEvent): void;
     protected onSelect(event: Event): void;
-    private isTargetItemExternal;
-    private isExternalItem;
     onPointerMove(event: IPointerEvent): void;
     onPointerUp(event: IPointerEvent): void;
     protected finalizeDragSequence(): void;
-    private emitSelectionChangeEvent;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [null, null, { optional: true; }, null, null, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; }, ["plugins"], never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableDirective, [{ optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": { "alias": "fDraggableDisabled"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; "fDropToGroup": "fDropToGroup"; }, ["plugins"], never, false, never>;
 }

package/f-draggable/i-draggable-item.d.ts

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/2d';
 export interface IDraggableItem {
-    initialize?(): void;
-    move(difference: IPoint): void;
-    complete?(): void;
+    prepareDragSequence?(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp?(): void;
 }

package/f-draggable/index.d.ts

@@ -1,6 +1,7 @@
 export * from './canvas';
 export * from './connections';
 export * from './domain';
+export * from '../domain/f-draggable/is-drag-started';
 export * from './node';
 export * from './node-resize';
 export * from './single-select';

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

@@ -13,11 +13,11 @@ export declare abstract class ConnectionBaseDragHandler implements IDraggableIte
     protected fOutputWithRect: IConnectorWithRect;
     protected fInputWithRect: IConnectorWithRect;
     protected constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase);
-    initialize(): void;
+    prepareDragSequence(): void;
     private getOutput;
     private getInput;
     private connectorNotFoundPrefix;
-    abstract move(difference: IPoint): void;
+    abstract onPointerMove(difference: IPoint): void;
     protected getDifference(difference: IPoint, restrictions: INodeMoveRestrictions): IPoint;
     protected redrawConnection(line: ILine): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionBaseDragHandler, never>;

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

@@ -7,6 +7,6 @@ export declare class ConnectionSourceDragHandler extends ConnectionBaseDragHandl
     minDistance: IPoint;
     maxDistance: IPoint;
     constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase, minDistance: IPoint, maxDistance: IPoint);
-    move(difference: IPoint): void;
+    onPointerMove(difference: IPoint): void;
     private getNewLineValue;
 }

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

@@ -7,6 +7,6 @@ export declare class ConnectionTargetDragHandler extends ConnectionBaseDragHandl
     minDistance: IPoint;
     maxDistance: IPoint;
     constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase, minDistance: IPoint, maxDistance: IPoint);
-    move(difference: IPoint): void;
+    onPointerMove(difference: IPoint): void;
     private getNewLineValue;
 }

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

@@ -9,6 +9,6 @@ export declare class ConnectionDragHandler extends ConnectionBaseDragHandler {
     constructor(fMediator: FMediator, fComponentsStore: FComponentsStore, connection: FConnectionBase);
     setOutputRestrictions(min: IPoint, max: IPoint): void;
     setInputRestrictions(min: IPoint, max: IPoint): void;
-    move(difference: IPoint): void;
+    onPointerMove(difference: IPoint): void;
     private getNewLineValue;
 }

package/f-draggable/node/create-move-nodes-drag-model-from-selection/create-move-nodes-drag-model-from-selection.execution.d.ts

@@ -11,6 +11,7 @@ export declare class CreateMoveNodesDragModelFromSelectionExecution implements I
     constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
     handle(request: CreateMoveNodesDragModelFromSelectionRequest): IDraggableItem[];
     private getSelectedNodes;
+    private _findNode;
     private getNodesWithRestrictions;
     private getChildrenItemsToDrag;
     private getChildrenNodes;

package/f-draggable/node/f-drop-to-group.event.d.ts

@@ -0,0 +1,7 @@
+import { IPoint } from '@foblex/2d';
+export declare class FDropToGroupEvent {
+    fTargetNode: string;
+    fNodes: string[];
+    fDropPosition: IPoint;
+    constructor(fTargetNode: string, fNodes: string[], fDropPosition: IPoint);
+}

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

@@ -1,10 +1,14 @@
 export * from './create-move-nodes-drag-model-from-selection';
+export * from './node-drag-to-parent-finalize';
+export * from './node-drag-to-parent-preparation';
 export * from './node-move-preparation';
 export * from './node-move-finalize';
 export * from './connection.drag-handler';
 export * from './connection-base-drag-handler';
 export * from './connection-source.drag-handler';
 export * from './connection-target.drag-handler';
+export * from './f-drop-to-group.event';
 export * from './node.drag-handler';
+export * from './node-drag-to-parent.drag-handler';
 export * from './node-resize-by-child.drag-handler';
 export * from './providers';

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

@@ -0,0 +1,4 @@
+export * from './providers';
+export * from './node-drag-to-parent-finalize.execution';
+export * from './node-drag-to-parent-finalize.request';
+export * from './node-drag-to-parent-finalize.validator';

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

@@ -0,0 +1,17 @@
+import { NodeDragToParentFinalizeRequest } from './node-drag-to-parent-finalize.request';
+import { IExecution } from '@foblex/mediator';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { FComponentsStore } from '../../../f-storage';
+import * as i0 from "@angular/core";
+export declare class NodeDragToParentFinalizeExecution implements IExecution<NodeDragToParentFinalizeRequest, void> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext);
+    handle(request: NodeDragToParentFinalizeRequest): void;
+    private emitDroppedChildrenEvent;
+    private getDragHandleItem;
+    private findDragHandleItem;
+    private getDraggedNodeIds;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDragToParentFinalizeExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeDragToParentFinalizeExecution>;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { NodeDragToParentFinalizeRequest } from './node-drag-to-parent-finalize.request';
+import { IValidator } from '@foblex/mediator';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import * as i0 from "@angular/core";
+export declare class NodeDragToParentFinalizeValidator implements IValidator<NodeDragToParentFinalizeRequest> {
+    private fDraggableDataContext;
+    constructor(fDraggableDataContext: FDraggableDataContext);
+    handle(request: NodeDragToParentFinalizeRequest): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDragToParentFinalizeValidator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeDragToParentFinalizeValidator>;
+}

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

@@ -0,0 +1,3 @@
+import { NodeDragToParentFinalizeExecution } from './node-drag-to-parent-finalize.execution';
+import { NodeDragToParentFinalizeValidator } from './node-drag-to-parent-finalize.validator';
+export declare const NODE_DRAG_TO_PARENT_FINALIZE_PROVIDERS: (typeof NodeDragToParentFinalizeExecution | typeof NodeDragToParentFinalizeValidator)[];

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

@@ -0,0 +1,4 @@
+export * from './providers';
+export * from './node-drag-to-parent-preparation.execution';
+export * from './node-drag-to-parent-preparation.request';
+export * from './node-drag-to-parent-preparation.validator';

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

@@ -0,0 +1,20 @@
+import { NodeDragToParentPreparationRequest } from './node-drag-to-parent-preparation.request';
+import { FMediator, IExecution } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import * as i0 from "@angular/core";
+export declare class NodeDragToParentPreparationExecution implements IExecution<NodeDragToParentPreparationRequest, void> {
+    private fMediator;
+    private fDraggableDataContext;
+    private fComponentsStore;
+    private get fNodes();
+    private get transform();
+    private get fCanvasPosition();
+    constructor(fMediator: FMediator, fDraggableDataContext: FDraggableDataContext, fComponentsStore: FComponentsStore);
+    handle(request: NodeDragToParentPreparationRequest): void;
+    private getNotDraggedNodesRects;
+    private getDraggedNodes;
+    private getNotDraggedNodes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDragToParentPreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeDragToParentPreparationExecution>;
+}

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

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

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

@@ -0,0 +1,11 @@
+import { NodeDragToParentPreparationRequest } from './node-drag-to-parent-preparation.request';
+import { IValidator } from '@foblex/mediator';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import * as i0 from "@angular/core";
+export declare class NodeDragToParentPreparationValidator implements IValidator<NodeDragToParentPreparationRequest> {
+    private fDraggableDataContext;
+    constructor(fDraggableDataContext: FDraggableDataContext);
+    handle(request: NodeDragToParentPreparationRequest): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDragToParentPreparationValidator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeDragToParentPreparationValidator>;
+}

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

@@ -0,0 +1,3 @@
+import { NodeDragToParentPreparationExecution } from './node-drag-to-parent-preparation.execution';
+import { NodeDragToParentPreparationValidator } from './node-drag-to-parent-preparation.validator';
+export declare const NODE_DRAG_TO_PARENT_PREPARATION_PROVIDERS: (typeof NodeDragToParentPreparationExecution | typeof NodeDragToParentPreparationValidator)[];

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

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { IDraggableItem } from '../i-draggable-item';
+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 {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    private notDraggedNodesRects;
+    private get transform();
+    private onPointerDownPosition;
+    fNodeWithRect: INodeWithRect | null;
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, notDraggedNodesRects: INodeWithRect[]);
+    onPointerMove(difference: IPoint): void;
+    private markIncludeNode;
+    private unmarkIncludeNode;
+    onPointerUp(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDragToParentDragHandler, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NodeDragToParentDragHandler, never, never, {}, {}, never, never, false, never>;
+}