@foblex/flow 12.6.1 → 12.6.3

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

@@ -4,17 +4,19 @@ import { IPoint, IRect } from '@foblex/core';
 import { FFlowMediator } from '../infrastructure';
 import { FSelectionChangeEvent } from '../f-draggable';
 import { FComponentsStore } from '../f-storage';
+import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {
     private elementReference;
     private fComponentsStore;
     private fMediator;
+    private fBrowser;
     private subscription$;
     fFlowId: string;
     get hostElement(): HTMLElement;
     fLoaded: EventEmitter<void>;
     private isLoaded;
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     ngAfterContentInit(): void;
     private subscribeOnComponentsCountChanges;
@@ -29,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/domain/line-element.d.ts

@@ -1,8 +1,9 @@
 import { ILineAlignmentRect } from './i-line-alignment-rect';
+import { BrowserService } from '@foblex/platform';
 export declare class LineElement {
     private readonly hostElement;
     private readonly element;
-    constructor(hostElement: HTMLElement);
+    constructor(fBrowser: BrowserService, hostElement: HTMLElement);
     hide(): void;
     show(): void;
     draw(object: Partial<ILineAlignmentRect>): void;

package/f-line-alignment/domain/line-service.d.ts

@@ -1,9 +1,10 @@
 import { ISize, ITransformModel } from '@foblex/core';
+import { BrowserService } from '@foblex/platform';
 export declare class LineService {
     private hostElement;
     private fHorizontalLine;
     private fVerticalLine;
-    constructor(hostElement: HTMLElement);
+    constructor(fBrowser: BrowserService, hostElement: HTMLElement);
     drawVerticalLine(x: number, size: ISize, transform: ITransformModel): void;
     drawHorizontalLine(y: number, size: ISize, transform: ITransformModel): void;
     hideVerticalLine(): void;

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

@@ -6,6 +6,7 @@ import { FComponentsStore } from '../f-storage';
 import { FDraggableDataContext } from '../f-draggable';
 import { FNodeBase } from '../f-node';
 import { FFlowMediator } from '../infrastructure';
+import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {
     private elementReference;
@@ -20,7 +21,7 @@ export declare class FLineAlignmentComponent extends FLineAlignmentBase implemen
     private rects;
     private get transform();
     private get flowHost();
-    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator);
+    constructor(elementReference: ElementRef<HTMLElement>, fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext, fMediator: FFlowMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void;
     handle(difference: IPoint): void;
@@ -28,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/domain/providers.d.ts

@@ -1,2 +1,2 @@
 import { CalculateFlowPointFromMinimapPointExecution } from './calculate-flow-point-from-minimap-point';
-export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPointExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationValidator | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeValidator)[];
+export declare const F_MINIMAP_DRAG_AND_DROP_PROVIDERS: (typeof CalculateFlowPointFromMinimapPointExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeExecution | typeof import("./minimap-drag-finalize").MinimapDragFinalizeValidator | typeof import("./minimap-drag-preparation").MinimapDragPreparationExecution | typeof import("./minimap-drag-preparation").MinimapDragPreparationValidator)[];

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

@@ -1,13 +1,15 @@
 import { ElementRef } from "@angular/core";
 import { FComponentsStore } from '../f-storage';
+import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FMinimapCanvasDirective {
     private elementReference;
     private fComponentsStore;
+    private fBrowser;
     get hostElement(): SVGGElement;
     private get flowHost();
     private get flowScale();
-    constructor(elementReference: ElementRef<SVGGElement>, fComponentsStore: FComponentsStore);
+    constructor(elementReference: ElementRef<SVGGElement>, fComponentsStore: FComponentsStore, fBrowser: BrowserService);
     redraw(): void;
     private clearCanvas;
     private renderNode;
@@ -16,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

@@ -4,12 +4,14 @@ import { FNodeBase } from './f-node-base';
 import { FComponentsStore } from '../f-storage';
 import { FConnectorBase } from '../f-connectors';
 import { FFlowMediator } from '../infrastructure';
+import { BrowserService } from '@foblex/platform';
 import * as i0 from "@angular/core";
 export declare class FGroupDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private elementReference;
     private renderer;
     private fComponentsStore;
     private fMediator;
+    private fBrowser;
     private subscriptions$;
     fId: string;
     fParentId: string | null | undefined;
@@ -25,7 +27,7 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     fConnectOnNode: boolean;
     get hostElement(): HTMLElement;
     connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
@@ -36,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

@@ -1,5 +1,6 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
 import { IHasHostElement, IPoint, IRect, ISize } from '@foblex/core';
+import { BrowserService } from '@foblex/platform';
 import { FComponentsStore } from '../f-storage';
 import { FConnectorBase } from '../f-connectors';
 import { FFlowMediator } from '../infrastructure';
@@ -10,6 +11,7 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     private renderer;
     private fComponentsStore;
     private fMediator;
+    private fBrowser;
     private subscriptions$;
     fId: string;
     fParentId: string | null | undefined;
@@ -25,7 +27,7 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     fConnectOnNode: boolean;
     get hostElement(): HTMLElement;
     connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
@@ -36,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/domain/selection-area-preparation/selection-area-preparation.validator.d.ts

@@ -7,6 +7,7 @@ export declare class SelectionAreaPreparationValidator implements IValidator<Sel
     constructor(fDraggableDataContext: FDraggableDataContext);
     handle(request: SelectionAreaPreparationRequest): boolean;
     private isDragHandlesEmpty;
+    private isShiftPressed;
     static ɵfac: i0.ɵɵFactoryDeclaration<SelectionAreaPreparationValidator, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SelectionAreaPreparationValidator>;
 }

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>;
 }