@foblex/flow 14.0.0 → 16.0.1

package/esm2022/f-zoom/f-zoom-base.mjs

@@ -0,0 +1,97 @@
+import { EventExtensions } from '@foblex/drag-toolkit';
+import { Point, RectExtensions } from '@foblex/2d';
+import { InjectionToken } from '@angular/core';
+import { isNode } from '../f-node';
+export const F_ZOOM = new InjectionToken('F_ZOOM');
+export class FZoomBase {
+    get flowHost() {
+        return this.fComponentsStore.flowHost;
+    }
+    get fCanvas() {
+        return this.fComponentsStore.fCanvas;
+    }
+    constructor(fComponentsStore) {
+        this.fComponentsStore = fComponentsStore;
+        this.isEnabled = false;
+        this.listeners = EventExtensions.emptyListener();
+    }
+    toggleZoom() {
+        if (this.isEnabled) {
+            this.subscribe();
+        }
+        else {
+            this.unsubscribe();
+        }
+    }
+    subscribe() {
+        this.listeners();
+        if (!this.flowHost) {
+            return;
+        }
+        this.flowHost.addEventListener('wheel', this.onWheel.bind(this));
+        this.flowHost.addEventListener('dblclick', this.onDoubleClick.bind(this));
+        this.listeners = () => {
+            this.flowHost.removeEventListener('wheel', this.onWheel.bind(this));
+            this.flowHost.removeEventListener('dblclick', this.onDoubleClick.bind(this));
+        };
+    }
+    getScale() {
+        return this.fCanvas.transform.scale || 1;
+    }
+    onWheel(event) {
+        event.preventDefault();
+        const targetElement = event.target;
+        if (this.fComponentsStore.fDraggable?.isDragStarted || targetElement?.closest('[fLockedContext]')) {
+            return;
+        }
+        let result = this.getScale();
+        const direction = event.deltaY > 0 ? -1 : 1;
+        const step = this.step;
+        result = result + step * direction;
+        result = Math.max(this.minimum, Math.min(result, this.maximum));
+        const pointerPositionInFlow = new Point(event.clientX, event.clientY).elementTransform(this.flowHost);
+        this.fCanvas.setZoom(result, pointerPositionInFlow);
+        this.fCanvas.redraw();
+        this.fCanvas.emitCanvasChangeEvent();
+    }
+    onDoubleClick(event) {
+        event.preventDefault();
+        const targetElement = event.target;
+        if (this.fComponentsStore.fDraggable?.isDragStarted || isNode(targetElement) || targetElement?.closest('[fLockedContext]')) {
+            return;
+        }
+        let result = this.getScale();
+        const direction = 1;
+        const step = this.dblClickStep;
+        result = result + step * direction;
+        result = Math.max(this.minimum, Math.min(result, this.maximum));
+        const pointerPositionInFlow = new Point(event.clientX, event.clientY).elementTransform(this.flowHost);
+        this.fCanvas.setZoom(result, pointerPositionInFlow);
+        this.fCanvas.redrawWithAnimation();
+        this.fCanvas.emitCanvasChangeEvent();
+    }
+    onZoomToCenter(deltaY, position) {
+        const preventDefault = () => {
+        };
+        const rect = RectExtensions.fromElement(this.flowHost);
+        this.onWheel({
+            deltaY, preventDefault, clientX: position?.x || rect.gravityCenter.x, clientY: position?.y || rect.gravityCenter.y
+        });
+    }
+    zoomIn(position) {
+        this.onZoomToCenter(-1, position);
+    }
+    zoomOut(position) {
+        this.onZoomToCenter(1, position);
+    }
+    reset() {
+        this.fCanvas.resetZoom();
+        this.fCanvas.redraw();
+        this.fCanvas.emitCanvasChangeEvent();
+    }
+    unsubscribe() {
+        this.listeners();
+        this.listeners = EventExtensions.emptyListener();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-zoom-base.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-zoom/f-zoom-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventExtensions } from '@foblex/drag-toolkit';\nimport { IPoint, Point, RectExtensions } from '@foblex/2d';\nimport { InjectionToken } from '@angular/core';\nimport { FCanvasBase } from '../f-canvas';\nimport { FComponentsStore } from '../f-storage';\nimport { isNode } from '../f-node';\n\nexport const F_ZOOM = new InjectionToken<FZoomBase>('F_ZOOM');\n\nexport abstract class FZoomBase {\n\n  protected isEnabled: boolean = false;\n\n  public abstract minimum: number;\n  public abstract maximum: number;\n\n  public abstract step: number;\n  public abstract dblClickStep: number;\n\n  private listeners: Function = EventExtensions.emptyListener();\n\n  private get flowHost(): HTMLElement {\n    return this.fComponentsStore.flowHost;\n  }\n\n  private get fCanvas(): FCanvasBase {\n    return this.fComponentsStore.fCanvas as FCanvasBase;\n  }\n\n  protected constructor(\n      protected fComponentsStore: FComponentsStore\n  ) {\n  }\n\n  protected toggleZoom(): void {\n    if (this.isEnabled) {\n      this.subscribe();\n    } else {\n      this.unsubscribe();\n    }\n  }\n\n  private subscribe(): void {\n    this.listeners();\n    if (!this.flowHost) {\n      return;\n    }\n\n    this.flowHost.addEventListener('wheel', this.onWheel.bind(this));\n    this.flowHost.addEventListener('dblclick', this.onDoubleClick.bind(this));\n    this.listeners = () => {\n      this.flowHost.removeEventListener('wheel', this.onWheel.bind(this));\n      this.flowHost.removeEventListener('dblclick', this.onDoubleClick.bind(this));\n    };\n  }\n\n  public getScale(): number {\n    return this.fCanvas.transform.scale || 1;\n  }\n\n  private onWheel(event: WheelEvent): void {\n    event.preventDefault();\n    const targetElement = event.target as HTMLElement;\n\n    if (this.fComponentsStore.fDraggable?.isDragStarted || targetElement?.closest('[fLockedContext]')) {\n      return;\n    }\n\n    let result: number = this.getScale();\n\n    const direction = event.deltaY > 0 ? -1 : 1;\n    const step = this.step;\n    result = result + step * direction;\n\n    result = Math.max(this.minimum, Math.min(result, this.maximum));\n\n    const pointerPositionInFlow = new Point(event.clientX, event.clientY).elementTransform(this.flowHost);\n\n    this.fCanvas.setZoom(result, pointerPositionInFlow);\n    this.fCanvas.redraw();\n    this.fCanvas.emitCanvasChangeEvent();\n  }\n\n  private onDoubleClick(event: MouseEvent): void {\n    event.preventDefault();\n    const targetElement = event.target as HTMLElement;\n\n    if (this.fComponentsStore.fDraggable?.isDragStarted || isNode(targetElement) || targetElement?.closest('[fLockedContext]')) {\n      return;\n    }\n\n    let result: number = this.getScale();\n\n    const direction = 1;\n    const step = this.dblClickStep;\n    result = result + step * direction;\n\n    result = Math.max(this.minimum, Math.min(result, this.maximum));\n\n    const pointerPositionInFlow = new Point(event.clientX, event.clientY).elementTransform(this.flowHost);\n    this.fCanvas.setZoom(result, pointerPositionInFlow);\n    this.fCanvas.redrawWithAnimation();\n    this.fCanvas.emitCanvasChangeEvent();\n  }\n\n  private onZoomToCenter(deltaY: number, position?: IPoint): void {\n    const preventDefault = () => {\n    };\n    const rect = RectExtensions.fromElement(this.flowHost);\n\n    this.onWheel({\n      deltaY, preventDefault, clientX: position?.x || rect.gravityCenter.x, clientY: position?.y || rect.gravityCenter.y\n    } as WheelEvent);\n  }\n\n  public zoomIn(position?: IPoint): void {\n    this.onZoomToCenter(-1, position);\n  }\n\n  public zoomOut(position?: IPoint): void {\n    this.onZoomToCenter(1, position);\n  }\n\n  public reset(): void {\n    this.fCanvas.resetZoom();\n    this.fCanvas.redraw();\n    this.fCanvas.emitCanvasChangeEvent();\n  }\n\n  protected unsubscribe(): void {\n    this.listeners();\n    this.listeners = EventExtensions.emptyListener();\n  }\n}\n"]}

package/esm2022/f-zoom/f-zoom.directive.mjs

@@ -0,0 +1,59 @@
+import { Directive, Input } from "@angular/core";
+import { F_ZOOM, FZoomBase } from './f-zoom-base';
+import { castToBoolean } from '@foblex/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-storage";
+export class FZoomDirective extends FZoomBase {
+    get fFlowZoom() {
+        return this.isEnabled;
+    }
+    set fFlowZoom(isEnabled) {
+        const value = castToBoolean(isEnabled);
+        if (value !== this.isEnabled) {
+            this.isEnabled = value;
+            this.toggleZoom();
+        }
+    }
+    constructor(fComponentsStore) {
+        super(fComponentsStore);
+        this.minimum = 0.1;
+        this.maximum = 4;
+        this.step = 0.1;
+        this.dblClickStep = 0.5;
+    }
+    ngAfterViewInit() {
+        super.toggleZoom();
+    }
+    ngOnDestroy() {
+        super.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FZoomDirective, deps: [{ token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FZoomDirective, selector: "f-canvas[fZoom]", inputs: { fFlowZoom: ["fZoom", "fFlowZoom"], minimum: ["fZoomMinimum", "minimum"], maximum: ["fZoomMaximum", "maximum"], step: ["fZoomStep", "step"], dblClickStep: ["fZoomDblClickStep", "dblClickStep"] }, host: { classAttribute: "f-zoom f-component" }, providers: [{ provide: F_ZOOM, useExisting: FZoomDirective }], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FZoomDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "f-canvas[fZoom]",
+                    exportAs: 'fComponent',
+                    host: {
+                        'class': 'f-zoom f-component'
+                    },
+                    providers: [{ provide: F_ZOOM, useExisting: FZoomDirective }],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }]; }, propDecorators: { fFlowZoom: [{
+                type: Input,
+                args: ['fZoom']
+            }], minimum: [{
+                type: Input,
+                args: ['fZoomMinimum']
+            }], maximum: [{
+                type: Input,
+                args: ['fZoomMaximum']
+            }], step: [{
+                type: Input,
+                args: ['fZoomStep']
+            }], dblClickStep: [{
+                type: Input,
+                args: ['fZoomDblClickStep']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/mixins/change-selection/change-selection.mjs

@@ -0,0 +1,28 @@
+export const F_SELECTED_CLASS = 'f-selected';
+export function mixinChangeSelection(base) {
+    return class extends base {
+        deselect() {
+            this.deselectChild?.();
+            this.hostElement.classList.remove(F_SELECTED_CLASS);
+        }
+        select() {
+            this.selectChild?.();
+            if (!this.isSelected()) {
+                this.hostElement.classList.add(F_SELECTED_CLASS);
+            }
+        }
+        isSelected() {
+            return this.hostElement.classList.contains(F_SELECTED_CLASS);
+        }
+        selectChild() {
+        }
+        deselectChild() {
+        }
+        constructor(...args) {
+            super(...args);
+            this.fId = '';
+            this.fSelectionDisabled = false;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/f-backgroud/f-background-base.d.ts

@@ -8,5 +8,5 @@ export declare abstract class FBackgroundBase implements IHasHostElement {
     abstract isBackgroundElement(element: HTMLElement | SVGElement): boolean;
     abstract setTransform(transform: ITransformModel): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FBackgroundBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FBackgroundBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-backgroud/f-background.component.d.ts

@@ -18,5 +18,5 @@ export declare class FBackgroundComponent extends FBackgroundBase implements OnI
     setTransform(transform: ITransformModel): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FBackgroundComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FBackgroundComponent, "f-background", never, {}, {}, ["fBackgroundPattern"], ["*"], false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FBackgroundComponent, "f-background", never, {}, {}, ["fBackgroundPattern"], ["*"], false, never>;
 }

package/f-backgroud/f-circle-pattern/f-circle-pattern.component.d.ts

@@ -30,5 +30,5 @@ export declare class FCirclePatternComponent implements OnInit, OnDestroy, IFBac
     setTransform(transform: ITransformModel): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCirclePatternComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FCirclePatternComponent, "f-circle-pattern", never, { "id": "id"; "color": "color"; "radius": "radius"; }, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FCirclePatternComponent, "f-circle-pattern", never, { "id": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-backgroud/f-rect-pattern/f-rect-pattern.component.d.ts

@@ -35,5 +35,5 @@ export declare class FRectPatternComponent implements OnInit, OnDestroy, IFBackg
     setTransform(transform: ITransformModel): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FRectPatternComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FRectPatternComponent, "f-rect-pattern", never, { "id": "id"; "vColor": "vColor"; "hColor": "hColor"; "vSize": "vSize"; "hSize": "hSize"; }, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FRectPatternComponent, "f-rect-pattern", never, { "id": { "alias": "id"; "required": false; }; "vColor": { "alias": "vColor"; "required": false; }; "hColor": { "alias": "hColor"; "required": false; }; "vSize": { "alias": "vSize"; "required": false; }; "hSize": { "alias": "hSize"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -21,5 +21,5 @@ export declare abstract class FCanvasBase implements IHasHostElement {
     abstract resetZoom(): void;
     emitCanvasChangeEvent(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FCanvasBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FCanvasBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -28,5 +28,5 @@ export declare class FCanvasComponent extends FCanvasBase implements OnInit {
     setZoom(scale: number, toPosition?: IPoint): void;
     resetZoom(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FCanvasComponent, "f-canvas", ["fComponent"], { "position": "position"; "scale": "scale"; }, { "fCanvasChange": "fCanvasChange"; }, never, ["[fGroup]", "f-snap-connection", "f-connection", "f-connection-for-create", "[fNode]"], false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FCanvasComponent, "f-canvas", ["fComponent"], { "position": { "alias": "position"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; }, { "fCanvasChange": "fCanvasChange"; }, never, ["[fGroup]", "f-snap-connection", "f-connection", "f-connection-for-create", "[fNode]"], false, never>;
 }

package/f-connection/common/f-connection-base.d.ts

@@ -58,6 +58,6 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements IHas
     deselectChild(): void;
     redraw(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, {}, {}, never, never, false, never>;
 }
 export {};

package/f-connection/common/f-connection-text/f-connection-text-path.directive.d.ts

@@ -18,5 +18,5 @@ export declare class FConnectionTextPathDirective implements IHasHostElement, On
     private getFontStyles;
     private getSymbolWidth;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionTextPathDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionTextPathDirective, "textPath[f-connection-text-path]", never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionTextPathDirective, "textPath[f-connection-text-path]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-connection-text/f-connection-text.component.d.ts

@@ -18,5 +18,5 @@ export declare class FConnectionTextComponent implements IConnectionText {
     private static isTextReverse;
     private static getTextStartOffset;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionTextComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionTextComponent, "text[f-connection-text]", never, {}, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionTextComponent, "text[f-connection-text]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-drag-handle/f-connection-drag-handle.component.d.ts

@@ -11,5 +11,5 @@ export declare class FConnectionDragHandleComponent implements IHasHostElement {
     redraw(penultimatePoint: IPoint, endPoint: IPoint): void;
     private calculateCircleCenter;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionDragHandleComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionDragHandleComponent, "circle[f-connection-drag-handle]", never, {}, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionDragHandleComponent, "circle[f-connection-drag-handle]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-gradient/f-connection-gradient.component.d.ts

@@ -18,5 +18,5 @@ export declare class FConnectionGradientComponent implements IConnectionGradient
     private setToColor;
     redraw(line: ILine): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientComponent, "linearGradient[fConnectionGradient]", never, {}, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientComponent, "linearGradient[fConnectionGradient]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-path/f-connection-path.component.d.ts

@@ -16,5 +16,5 @@ export declare class FConnectionPathComponent implements IConnectionPath {
     select(): void;
     deselect(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionPathComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPathComponent, "path[f-connection-path]", never, {}, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPathComponent, "path[f-connection-path]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/common/f-selection/f-connection-selection.component.d.ts

@@ -10,5 +10,5 @@ export declare class FConnectionSelectionComponent implements IHasHostElement {
     constructor(elementReference: ElementRef<SVGPathElement>, base: IHasConnectionFromTo);
     setPath(path: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionSelectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelectionComponent, "path[fConnectionSelection]", never, {}, {}, never, never, false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelectionComponent, "path[fConnectionSelection]", never, {}, {}, never, never, false, never>;
 }

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

@@ -52,5 +52,5 @@ export declare class FConnectionComponent extends FConnectionBase implements OnI
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": "fConnectionId"; "fText": "fText"; "fStartColor": "fStartColor"; "fEndColor": "fEndColor"; "fOutputId": "fOutputId"; "fInputId": "fInputId"; "fRadius": "fRadius"; "fOffset": "fOffset"; "fBehavior": "fBehavior"; "fType": "fType"; "fDraggingDisabled": "fReassignDisabled"; "fSelectionDisabled": "fSelectionDisabled"; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; }; "fText": { "alias": "fText"; "required": false; }; "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "required": false; }; "fOutputId": { "alias": "fOutputId"; "required": false; }; "fInputId": { "alias": "fInputId"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; }; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false, never>;
 }

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

@@ -1,5 +1,5 @@
 import * as i0 from "@angular/core";
 export declare class FConnectionCenterDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionCenterDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionCenterDirective, "[fConnectionCenter]", never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionCenterDirective, "[fConnectionCenter]", never, {}, {}, never, never, false, never>;
 }

package/f-connection/f-connection-for-create/f-connection-for-create.component.d.ts

@@ -47,5 +47,5 @@ export declare class FConnectionForCreateComponent extends FConnectionBase imple
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionForCreateComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fStartColor": "fStartColor"; "fEndColor": "fEndColor"; "fRadius": "fRadius"; "fOffset": "fOffset"; "fBehavior": "fBehavior"; "fType": "fType"; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fStartColor": { "alias": "fStartColor"; "required": false; }; "fEndColor": { "alias": "fEndColor"; "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>;
 }

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

@@ -12,5 +12,5 @@ export declare abstract class FMarkerBase implements IHasHostElement {
     abstract orient: 'auto' | 'auto-start-reverse' | string;
     abstract markerUnits: 'strokeWidth' | 'userSpaceOnUse';
     static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -17,5 +17,5 @@ export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnD
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerDirective, "svg[fMarker]", never, { "hostElement": "hostElement"; "width": "width"; "height": "height"; "refX": "refX"; "refY": "refY"; "type": "type"; "orient": "orient"; "markerUnits": "markerUnits"; }, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerDirective, "svg[fMarker]", never, { "hostElement": { "alias": "hostElement"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "refX": { "alias": "refX"; "required": false; }; "refY": { "alias": "refY"; "required": false; }; "type": { "alias": "type"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "markerUnits": { "alias": "markerUnits"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -48,5 +48,5 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fStartColor": "fStartColor"; "fEndColor": "fEndColor"; "fSnapThreshold": "fSnapThreshold"; "fRadius": "fRadius"; "fOffset": "fOffset"; "fBehavior": "fBehavior"; "fType": "fType"; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"], false>;
+    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>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class FNodeInputBase extends FConnectorBase {
     isConnected: boolean;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -23,5 +23,5 @@ export declare class FNodeInputDirective extends FNodeInputBase implements OnIni
     setConnected(isConnected: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "id": "fInputId"; "multiple": "fInputMultiple"; "disabled": "fInputDisabled"; "_fSide": "fInputConnectableSide"; }, {}, never, never, false>;
+    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>;
 }

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

@@ -9,5 +9,5 @@ export declare abstract class FNodeOutletBase extends FConnectorBase {
     get canBeConnected(): boolean;
     setOutputs(outputs: FConnectorBase[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -20,5 +20,5 @@ export declare class FNodeOutletDirective extends FNodeOutletBase implements OnI
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "id": "fOutletId"; "disabled": "fOutletDisabled"; "isConnectionFromOutlet": "isConnectionFromOutlet"; }, {}, never, never, false>;
+    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>;
 }

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

@@ -7,5 +7,5 @@ export declare abstract class FNodeOutputBase extends FConnectorBase {
     isConnected: boolean;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -24,5 +24,5 @@ export declare class FNodeOutputDirective extends FNodeOutputBase implements OnI
     setConnected(isConnected: boolean): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "id": "fOutputId"; "multiple": "fOutputMultiple"; "disabled": "fOutputDisabled"; "_fSide": "fOutputConnectableSide"; "isSelfConnectable": "isSelfConnectable"; }, {}, never, never, false>;
+    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>;
 }

package/f-draggable/connections/providers.d.ts

@@ -1,4 +1,4 @@
 import { CreateConnectionDragHandlerExecution, CreateConnectionFinalizeExecution, CreateConnectionFinalizeValidator, CreateConnectionFromOutletPreparationExecution, CreateConnectionFromOutputPreparationExecution, CreateConnectionFromOutputPreparationValidator, CreateConnectionPreparationExecution, CreateConnectionPreparationValidator, GetCanBeConnectedOutputByOutletExecution, GetCanBeConnectedOutputByOutletValidator } from './create-connection';
 import { ReassignConnectionFinalizeExecution, ReassignConnectionFinalizeValidator, ReassignConnectionPreparationExecution, ReassignConnectionPreparationValidator } from './reassign-connection';
 import { GetInputUnderPointerExecution, GetInputUnderPointerValidator } from './get-input-under-pointer';
-export declare const CONNECTIONS_PROVIDERS: (typeof GetCanBeConnectedOutputByOutletExecution | typeof GetCanBeConnectedOutputByOutletValidator | typeof ReassignConnectionFinalizeExecution | typeof ReassignConnectionFinalizeValidator | typeof ReassignConnectionPreparationExecution | typeof ReassignConnectionPreparationValidator | typeof GetInputUnderPointerExecution | typeof GetInputUnderPointerValidator | typeof CreateConnectionFinalizeExecution | typeof CreateConnectionFinalizeValidator | typeof CreateConnectionDragHandlerExecution | typeof CreateConnectionFromOutletPreparationExecution | typeof CreateConnectionFromOutputPreparationExecution | typeof CreateConnectionFromOutputPreparationValidator | typeof CreateConnectionPreparationExecution | typeof CreateConnectionPreparationValidator)[];
+export declare const CONNECTIONS_PROVIDERS: (typeof GetInputUnderPointerExecution | typeof GetInputUnderPointerValidator | typeof CreateConnectionFinalizeExecution | typeof CreateConnectionFinalizeValidator | typeof CreateConnectionDragHandlerExecution | typeof CreateConnectionFromOutletPreparationExecution | typeof GetCanBeConnectedOutputByOutletExecution | typeof GetCanBeConnectedOutputByOutletValidator | typeof CreateConnectionFromOutputPreparationExecution | typeof CreateConnectionFromOutputPreparationValidator | typeof CreateConnectionPreparationExecution | typeof CreateConnectionPreparationValidator | typeof ReassignConnectionFinalizeExecution | typeof ReassignConnectionFinalizeValidator | typeof ReassignConnectionPreparationExecution | typeof ReassignConnectionPreparationValidator)[];

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

@@ -11,5 +11,5 @@ export declare abstract class FDraggableBase extends DragAndDropBase {
     abstract fCreateConnection: EventEmitter<FCreateConnectionEvent>;
     protected constructor(ngZone: ICanRunOutsideAngular | undefined);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -37,5 +37,5 @@ export declare class FDraggableDirective extends FDraggableBase implements OnIni
     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": "fDraggableDisabled"; }, { "fSelectionChange": "fSelectionChange"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; }, ["plugins"], never, false>;
+    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>;
 }

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

@@ -20,5 +20,5 @@ export declare abstract class ConnectionBaseDragHandler implements IDraggableIte
     protected getDifference(difference: IPoint, restrictions: INodeMoveRestrictions): IPoint;
     protected redrawConnection(line: ILine): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionBaseDragHandler, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ConnectionBaseDragHandler, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConnectionBaseDragHandler, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -2,4 +2,4 @@ import { CreateMoveNodesDragModelFromSelectionExecution } from './create-move-no
 import { GetNodeMoveRestrictionsExecution } from './domain/get-node-move-restrictions';
 import { PutInputConnectionHandlersToArrayExecution } from './domain/put-input-connection-handlers-to-array';
 import { PutOutputConnectionHandlersToArrayExecution } from './domain/put-output-connection-handlers-to-array';
-export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof GetNodeMoveRestrictionsExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];
+export declare const CREATE_MOVE_NODE_DRAG_MODEL_FROM_SELECTION_PROVIDERS: (typeof GetNodeMoveRestrictionsExecution | typeof PutInputConnectionHandlersToArrayExecution | typeof PutOutputConnectionHandlersToArrayExecution | typeof CreateMoveNodesDragModelFromSelectionExecution)[];

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

@@ -1 +1 @@
-export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").GetNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-move-preparation").NodeMovePreparationValidator | typeof import("./node-move-finalize").NodeMoveFinalizeExecution | typeof import("./node-move-finalize").NodeMoveFinalizeValidator)[];
+export declare const NODE_PROVIDERS: (typeof import("./create-move-nodes-drag-model-from-selection").GetNodeMoveRestrictionsExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutInputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").PutOutputConnectionHandlersToArrayExecution | typeof import("./create-move-nodes-drag-model-from-selection").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node-move-finalize").NodeMoveFinalizeExecution | typeof import("./node-move-finalize").NodeMoveFinalizeValidator | typeof import("./node-move-preparation").NodeMovePreparationExecution | typeof import("./node-move-preparation").NodeMovePreparationValidator)[];

package/f-draggable/node-resize/get-node-resize-restrictions/get-node-resize-restrictions.execution.d.ts

@@ -6,6 +6,7 @@ export declare class GetNodeResizeRestrictionsExecution implements IExecution<Ge
     private fMediator;
     constructor(fMediator: FMediator);
     handle(request: GetNodeResizeRestrictionsRequest): INodeResizeRestrictions;
+    private getNodePaddings;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetNodeResizeRestrictionsExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetNodeResizeRestrictionsExecution>;
 }

package/f-draggable/node-resize/get-node-resize-restrictions/i-node-resize-restrictions.d.ts

@@ -1,5 +1,6 @@
-import { IRect } from '@foblex/2d';
+import { IRect, ISize } from '@foblex/2d';
 export interface INodeResizeRestrictions {
     parentRect: IRect;
     childRect: IRect | null;
+    minSize: ISize;
 }

package/f-draggable/node-resize/get-normalized-children-nodes-rect/get-normalized-children-nodes-rect.execution.d.ts

@@ -8,7 +8,6 @@ export declare class GetNormalizedChildrenNodesRectExecution implements IExecuti
     handle(request: GetNormalizedChildrenNodesRectRequest): IRect | null;
     private getChildrenNodes;
     private normalizeRect;
-    private getNodePadding;
     private concatRectWithParentPadding;
     static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedChildrenNodesRectExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedChildrenNodesRectExecution>;

package/f-draggable/node-resize/get-normalized-children-nodes-rect/get-normalized-children-nodes-rect.request.d.ts

@@ -1,7 +1,6 @@
 import { FNodeBase } from '../../../f-node';
-import { IRect } from '@foblex/2d';
 export declare class GetNormalizedChildrenNodesRectRequest {
     fNode: FNodeBase;
-    rect: IRect;
-    constructor(fNode: FNodeBase, rect: IRect);
+    paddings: [number, number, number, number];
+    constructor(fNode: FNodeBase, paddings: [number, number, number, number]);
 }

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

@@ -4,4 +4,4 @@ import { ApplyParentResizeRestrictionsExecution } from './apply-parent-resize-re
 import { CalculateChangedSizeExecution } from './calculate-changed-size';
 import { CalculateChangedPositionExecution } from './calculate-changed-position';
 import { GetNormalizedChildrenNodesRectExecution } from './get-normalized-children-nodes-rect';
-export declare const NODE_RESIZE_PROVIDERS: (typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof CalculateChangedSizeExecution | typeof GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeValidator | typeof import("./node-resize-preparation").NodeResizePreparationExecution | typeof import("./node-resize-preparation").NodeResizePreparationValidator)[];
+export declare const NODE_RESIZE_PROVIDERS: (typeof CalculateChangedSizeExecution | typeof GetNormalizedChildrenNodesRectExecution | typeof GetNodeResizeRestrictionsExecution | typeof ApplyChildResizeRestrictionsExecution | typeof ApplyParentResizeRestrictionsExecution | typeof CalculateChangedPositionExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeExecution | typeof import("./node-resize-finalize").NodeResizeFinalizeValidator | typeof import("./node-resize-preparation").NodeResizePreparationExecution | typeof import("./node-resize-preparation").NodeResizePreparationValidator)[];

package/f-draggable/providers.d.ts

@@ -1 +1 @@
-export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeValidator | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemFinalizeValidator | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeValidator | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionPreparationValidator | typeof import("./connections").GetInputUnderPointerExecution | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionFinalizeValidator | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationValidator | typeof import("./domain").GetNodePaddingExecution | typeof import("./domain").GetNormalizedNodeRectExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").GetParentNodesExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").GetNodeMoveRestrictionsExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMoveFinalizeValidator | 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").NodeResizeFinalizeValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("./single-select").SingleSelectExecution | typeof import("./single-select").SingleSelectValidator | typeof import("../f-minimap/domain").CalculateFlowPointFromMinimapPointExecution | typeof import("../f-minimap/domain").MinimapDragFinalizeExecution | typeof import("../f-minimap/domain").MinimapDragFinalizeValidator | typeof import("../f-minimap/domain").MinimapDragPreparationExecution | typeof import("../f-minimap/domain").MinimapDragPreparationValidator | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator)[];
+export declare const F_DRAGGABLE_PROVIDERS: (typeof import("./connections").GetInputUnderPointerExecution | typeof import("./node-resize").CalculateChangedSizeExecution | typeof import("./node-resize").GetNormalizedChildrenNodesRectExecution | typeof import("./node-resize").GetNodeResizeRestrictionsExecution | typeof import("./canvas").CanvasMoveFinalizeExecution | typeof import("./canvas").CanvasMoveFinalizeValidator | typeof import("./canvas").CanvasMovePreparationExecution | typeof import("./canvas").CanvasMovePreparationValidator | typeof import("./connections").GetInputUnderPointerValidator | typeof import("./connections").CreateConnectionFinalizeExecution | typeof import("./connections").CreateConnectionFinalizeValidator | typeof import("./connections").CreateConnectionDragHandlerExecution | typeof import("./connections").CreateConnectionFromOutletPreparationExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletExecution | typeof import("./connections").GetCanBeConnectedOutputByOutletValidator | typeof import("./connections").CreateConnectionFromOutputPreparationExecution | typeof import("./connections").CreateConnectionFromOutputPreparationValidator | typeof import("./connections").CreateConnectionPreparationExecution | typeof import("./connections").CreateConnectionPreparationValidator | typeof import("./connections").ReassignConnectionFinalizeExecution | typeof import("./connections").ReassignConnectionFinalizeValidator | typeof import("./connections").ReassignConnectionPreparationExecution | typeof import("./connections").ReassignConnectionPreparationValidator | typeof import("./domain").GetNodePaddingExecution | typeof import("./domain").GetNormalizedNodeRectExecution | typeof import("./domain").GetNormalizedParentNodeRectExecution | typeof import("./domain").GetParentNodesExecution | typeof import("./domain").IsArrayHasParentNodeExecution | typeof import("./single-select").SingleSelectExecution | typeof import("./single-select").SingleSelectValidator | typeof import("../f-external-item").ExternalItemFinalizeExecution | typeof import("../f-external-item").ExternalItemFinalizeValidator | typeof import("../f-external-item").ExternalItemPreparationExecution | typeof import("../f-external-item").ExternalItemPreparationValidator | typeof import("./node").GetNodeMoveRestrictionsExecution | typeof import("./node").PutInputConnectionHandlersToArrayExecution | typeof import("./node").PutOutputConnectionHandlersToArrayExecution | typeof import("./node").CreateMoveNodesDragModelFromSelectionExecution | typeof import("./node").NodeMoveFinalizeExecution | typeof import("./node").NodeMoveFinalizeValidator | typeof import("./node").NodeMovePreparationExecution | typeof import("./node").NodeMovePreparationValidator | typeof import("./node-resize").ApplyChildResizeRestrictionsExecution | typeof import("./node-resize").ApplyParentResizeRestrictionsExecution | typeof import("./node-resize").CalculateChangedPositionExecution | typeof import("./node-resize").NodeResizeFinalizeExecution | typeof import("./node-resize").NodeResizeFinalizeValidator | typeof import("./node-resize").NodeResizePreparationExecution | typeof import("./node-resize").NodeResizePreparationValidator | typeof import("../f-selection-area").SelectionAreaFinalizeExecution | typeof import("../f-selection-area").SelectionAreaFinalizeValidator | typeof import("../f-selection-area").SelectionAreaPreparationExecution | typeof import("../f-selection-area").SelectionAreaPreparationValidator | typeof import("../f-minimap/domain").CalculateFlowPointFromMinimapPointExecution | typeof import("../f-minimap/domain").MinimapDragFinalizeExecution | typeof import("../f-minimap/domain").MinimapDragFinalizeValidator | typeof import("../f-minimap/domain").MinimapDragPreparationExecution | typeof import("../f-minimap/domain").MinimapDragPreparationValidator)[];

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

@@ -8,5 +8,5 @@ export declare abstract class FExternalItemBase<TData = any> implements IHasHost
     abstract fData: TData | undefined;
     abstract fDisabled: boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemBase<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, never, never, false, never>;
 }

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

@@ -14,5 +14,5 @@ export declare class FExternalItemDirective<TData> extends FExternalItemBase<TDa
     private disablePointerEvents;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FExternalItemDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemDirective<any>, "[fExternalItem]", never, { "fExternalItemId": "fExternalItemId"; "fData": "fData"; "fDisabled": "fDisabled"; }, {}, never, never, false>;
+    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>;
 }