@foblex/flow 12.6.2 → 12.6.3

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": { "alias": "id"; "required": false; }; "color": { "alias": "color"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FCirclePatternComponent, "f-circle-pattern", never, { "id": "id"; "color": "color"; "radius": "radius"; }, {}, never, 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": { "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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FRectPatternComponent, "f-rect-pattern", never, { "id": "id"; "vColor": "vColor"; "hColor": "hColor"; "vSize": "vSize"; "hSize": "hSize"; }, {}, never, never>;
 }

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

@@ -22,6 +22,6 @@ export declare abstract class FCanvasBase extends MIXIN_BASE implements IHasHost
     completeDrag(): void;
     private getCanvasPosition;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FCanvasBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FCanvasBase, never, never, {}, {}, never>;
 }
 export {};

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

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

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

@@ -57,6 +57,6 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements IHas
     private getTransform;
     redraw(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, {}, {}, 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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionTextPathDirective, "textPath[f-connection-text-path]", never, {}, {}, 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, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionTextComponent, "text[f-connection-text]", never, {}, {}, never, never>;
 }

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

@@ -10,5 +10,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, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionDragHandleComponent, "circle[f-connection-drag-handle]", never, {}, {}, never, 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, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientComponent, "linearGradient[fConnectionGradient]", never, {}, {}, never, 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, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPathComponent, "path[f-connection-path]", never, {}, {}, never, 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, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionSelectionComponent, "path[fConnectionSelection]", never, {}, {}, never, never>;
 }

package/f-connection/common/mixins/change-connection-selection.mixin.d.ts

@@ -8,6 +8,6 @@ export interface ISelectable {
     isSelected(): boolean;
 }
 export declare const F_SELECTED_CLASS = "f-selected";
-type CanChangeConnectionSelectionConstructor = Constructor<ISelectable> & AbstractConstructor<ISelectable>;
+declare type CanChangeConnectionSelectionConstructor = Constructor<ISelectable> & AbstractConstructor<ISelectable>;
 export declare function mixinChangeConnectionSelection<T extends AbstractConstructor<IHasHostElement>>(base: T): CanChangeConnectionSelectionConstructor & T;
 export {};

package/f-connection/common/mixins/change-connection-visibility.mixin.d.ts

@@ -4,6 +4,6 @@ export interface ICanChangeConnectionVisibility {
     show(): void;
     hide(): void;
 }
-type CanChangeConnectionVisibilityConstructor = Constructor<ICanChangeConnectionVisibility> & AbstractConstructor<ICanChangeConnectionVisibility>;
+declare type CanChangeConnectionVisibilityConstructor = Constructor<ICanChangeConnectionVisibility> & AbstractConstructor<ICanChangeConnectionVisibility>;
 export declare function mixinChangeConnectionVisibility<T extends AbstractConstructor<IHasHostElement>>(base: T): CanChangeConnectionVisibilityConstructor & T;
 export {};

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

@@ -54,5 +54,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": { "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>;
+    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]"]>;
 }

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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionCenterDirective, "[fConnectionCenter]", never, {}, {}, never>;
 }

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

@@ -49,5 +49,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, { "fId": { "alias": "fConnectionId"; "required": false; }; "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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fId": "fConnectionId"; "fStartColor": "fStartColor"; "fEndColor": "fEndColor"; "fRadius": "fRadius"; "fOffset": "fOffset"; "fBehavior": "fBehavior"; "fType": "fType"; }, {}, ["fConnectionCenters"], ["*", "[fConnectionCenter]"]>;
 }

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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerBase, never, never, {}, {}, 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": { "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>;
+    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>;
 }

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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, 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": { "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"], { "id": "fInputId"; "multiple": "fInputMultiple"; "disabled": "fInputDisabled"; "_fSide": "fInputConnectableSide"; }, {}, 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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletBase, never, never, {}, {}, 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": { "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"], { "id": "fOutletId"; "disabled": "fOutletDisabled"; "isConnectionFromOutlet": "isConnectionFromOutlet"; }, {}, 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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, 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": { "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"], { "id": "fOutputId"; "multiple": "fOutputMultiple"; "disabled": "fOutputDisabled"; "_fSide": "fOutputConnectableSide"; "isSelfConnectable": "isSelfConnectable"; }, {}, never>;
 }

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

@@ -47,5 +47,5 @@ export declare abstract class FDraggableBase implements IHasHostElement {
     subscribe(fDocument: Document): void;
     unsubscribe(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FDraggableBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableBase, never, never, {}, {}, never>;
 }

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

@@ -38,5 +38,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": { "alias": "fDraggableDisabled"; "required": false; }; }, { "fSelectionChange": "fSelectionChange"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; }, ["plugins"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDraggableDirective, "f-flow[fDraggable]", ["fDraggable"], { "disabled": "fDraggableDisabled"; }, { "fSelectionChange": "fSelectionChange"; "fCreateNode": "fCreateNode"; "fReassignConnection": "fReassignConnection"; "fCreateConnection": "fCreateConnection"; }, ["plugins"]>;
 }

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

@@ -19,5 +19,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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConnectionBaseDragHandler, never, never, {}, {}, never>;
 }

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, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FExternalItemBase<any>, never, never, {}, {}, 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": { "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": "fExternalItemId"; "fData": "fData"; "fDisabled": "fDisabled"; }, {}, never>;
 }

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

@@ -31,5 +31,5 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     clearSelection(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FFlowComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fFlowId": { "alias": "fFlowId"; "required": false; }; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "f-minimap"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FFlowComponent, "f-flow", never, { "fFlowId": "fFlowId"; }, { "fLoaded": "fLoaded"; }, never, ["[fDefinitions]", "f-background", "f-line-alignment", "f-canvas", "f-selection-area", "f-minimap"]>;
 }

package/f-line-alignment/f-line-alignment-base.d.ts

@@ -11,5 +11,5 @@ export declare abstract class FLineAlignmentBase implements IHasHostElement {
     abstract handle(difference: IPoint): void;
     abstract complete(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FLineAlignmentBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FLineAlignmentBase, never, never, {}, {}, never>;
 }

package/f-line-alignment/f-line-alignment.component.d.ts

@@ -29,5 +29,5 @@ export declare class FLineAlignmentComponent extends FLineAlignmentBase implemen
     findNearestCoordinate(difference: IPoint): ILineAlignmentResult;
     complete(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FLineAlignmentComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], { "fAlignThreshold": { "alias": "fAlignThreshold"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FLineAlignmentComponent, "f-line-alignment", ["fComponent"], { "fAlignThreshold": "fAlignThreshold"; }, {}, never, never>;
 }

package/f-minimap/domain/check-rect-is-finite.d.ts

@@ -0,0 +1,2 @@
+import { IRect } from '@foblex/core';
+export declare function checkRectIsFinite(rect: IRect): IRect;

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

@@ -1,6 +1,7 @@
 export * from './calculate-flow-point-from-minimap-point';
 export * from './minimap-drag-finalize';
 export * from './minimap-drag-preparation';
+export * from './check-rect-is-finite';
 export * from './f-minimap.drag-handler';
 export * from './f-minimap-data';
 export * from './providers';

package/f-minimap/f-minimap-canvas.directive.d.ts

@@ -18,5 +18,5 @@ export declare class FMinimapCanvasDirective {
     private setElementAttributes;
     private applyClassList;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapCanvasDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never>;
 }

package/f-minimap/f-minimap-flow.directive.d.ts

@@ -24,5 +24,5 @@ export declare class FMinimapFlowDirective {
     private calculateCenteredViewBox;
     private setViewBox;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapFlowDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapFlowDirective, "svg[fMinimapFlow]", never, { "fMinSize": { "alias": "fMinSize"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapFlowDirective, "svg[fMinimapFlow]", never, { "fMinSize": "fMinSize"; }, {}, never>;
 }

package/f-minimap/f-minimap-view.directive.d.ts

@@ -10,5 +10,5 @@ export declare class FMinimapViewDirective {
     update(): void;
     private setAttributes;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapViewDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never>;
 }

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

@@ -22,5 +22,5 @@ export declare class FMinimapComponent implements AfterViewInit, OnDestroy, IFDr
     onPointerUp(event: IPointerEvent): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FMinimapComponent, "f-minimap", ["fComponent"], { "fMinSize": { "alias": "fMinSize"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FMinimapComponent, "f-minimap", ["fComponent"], { "fMinSize": "fMinSize"; }, {}, never, never>;
 }

package/f-node/f-drag-handle/f-drag-handle.directive.d.ts

@@ -7,5 +7,5 @@ export declare class FDragHandleDirective implements IHasHostElement {
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never>;
 }

package/f-node/f-group.directive.d.ts

@@ -38,5 +38,5 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": { "alias": "fGroupId"; "required": false; }; "fParentId": { "alias": "fGroupParentId"; "required": false; }; "position": { "alias": "fGroupPosition"; "required": false; }; "size": { "alias": "fGroupSize"; "required": false; }; "fDraggingDisabled": { "alias": "fGroupDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fGroupSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FGroupDirective, "[fGroup]", ["fComponent"], { "fId": "fGroupId"; "fParentId": "fGroupParentId"; "position": "fGroupPosition"; "size": "fGroupSize"; "fDraggingDisabled": "fGroupDraggingDisabled"; "fSelectionDisabled": "fGroupSelectionDisabled"; "fIncludePadding": "fIncludePadding"; "fConnectOnNode": "fConnectOnNode"; }, { "positionChange": "fGroupPositionChange"; "sizeChange": "fGroupSizeChange"; }, never>;
 }

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

@@ -38,5 +38,5 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": { "alias": "fNodeId"; "required": false; }; "fParentId": { "alias": "fNodeParentId"; "required": false; }; "position": { "alias": "fNodePosition"; "required": false; }; "size": { "alias": "fNodeSize"; "required": false; }; "fDraggingDisabled": { "alias": "fNodeDraggingDisabled"; "required": false; }; "fSelectionDisabled": { "alias": "fNodeSelectionDisabled"; "required": false; }; "fIncludePadding": { "alias": "fIncludePadding"; "required": false; }; "fConnectOnNode": { "alias": "fConnectOnNode"; "required": false; }; }, { "positionChange": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeDirective, "[fNode]", ["fComponent"], { "fId": "fNodeId"; "fParentId": "fNodeParentId"; "position": "fNodePosition"; "size": "fNodeSize"; "fDraggingDisabled": "fNodeDraggingDisabled"; "fSelectionDisabled": "fNodeSelectionDisabled"; "fIncludePadding": "fIncludePadding"; "fConnectOnNode": "fConnectOnNode"; }, { "positionChange": "fNodePositionChange"; "sizeChange": "fNodeSizeChange"; }, never>;
 }

package/f-node/f-resize-handle/f-resize-handle.directive.d.ts

@@ -12,5 +12,5 @@ export declare class FResizeHandleDirective implements IHasHostElement {
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FResizeHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": { "alias": "fResizeHandleType"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": "fResizeHandleType"; }, {}, never>;
 }

package/f-selection-area/f-selection-area-base.d.ts

@@ -6,5 +6,5 @@ export declare abstract class FSelectionAreaBase implements IHasHostElement {
     abstract show(): void;
     abstract draw(object: IRect): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSelectionAreaBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FSelectionAreaBase, never, never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FSelectionAreaBase, never, never, {}, {}, never>;
 }

package/f-selection-area/f-selection-area.component.d.ts

@@ -16,5 +16,5 @@ export declare class FSelectionAreaComponent extends FSelectionAreaBase implemen
     onPointerDown(event: IPointerEvent): void;
     onPointerUp(event: IPointerEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSelectionAreaComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FSelectionAreaComponent, "f-selection-area", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FSelectionAreaComponent, "f-selection-area", never, {}, {}, never, never>;
 }

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

@@ -13,5 +13,5 @@ export declare class FZoomDirective extends FZoomBase implements AfterViewInit,
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FZoomDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FZoomDirective, "f-canvas[fZoom]", ["fComponent"], { "fFlowZoom": { "alias": "fZoom"; "required": false; }; "minimum": { "alias": "fZoomMinimum"; "required": false; }; "maximum": { "alias": "fZoomMaximum"; "required": false; }; "step": { "alias": "fZoomStep"; "required": false; }; "dblClickStep": { "alias": "fZoomDblClickStep"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FZoomDirective, "f-canvas[fZoom]", ["fComponent"], { "fFlowZoom": "fZoom"; "minimum": "fZoomMinimum"; "maximum": "fZoomMaximum"; "step": "fZoomStep"; "dblClickStep": "fZoomDblClickStep"; }, {}, never>;
 }