@foblex/flow 12.4.0 → 12.5.0

package/f-minimap/domain/calculate-flow-point-from-minimap-point/calculate-flow-point-from-minimap-point.execution.d.ts

@@ -0,0 +1,18 @@
+import { IPoint, Point } from '@foblex/core';
+import { CalculateFlowPointFromMinimapPointRequest } from './calculate-flow-point-from-minimap-point.request';
+import { FComponentsStore } from '../../../f-storage';
+import { IExecution } from '../../../infrastructure';
+import { FMinimapData } from '../f-minimap-data';
+import * as i0 from "@angular/core";
+export declare class CalculateFlowPointFromMinimapPointExecution implements IExecution<CalculateFlowPointFromMinimapPointRequest, IPoint> {
+    private fComponentsStore;
+    private get canvasScale();
+    constructor(fComponentsStore: FComponentsStore);
+    handle(payload: CalculateFlowPointFromMinimapPointRequest): IPoint;
+    private getNormalizedFlowCenter;
+    private getPositionInViewBox;
+    normalizeEventPoint(point: IPoint, minimap: FMinimapData): Point;
+    private getEventPointInMinimap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateFlowPointFromMinimapPointExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateFlowPointFromMinimapPointExecution>;
+}

package/f-minimap/domain/calculate-flow-point-from-minimap-point/calculate-flow-point-from-minimap-point.request.d.ts

@@ -0,0 +1,9 @@
+import { IPoint, IRect } from '@foblex/core';
+import { FMinimapData } from '../f-minimap-data';
+export declare class CalculateFlowPointFromMinimapPointRequest {
+    flowRect: IRect;
+    canvasPosition: IPoint;
+    eventPoint: IPoint;
+    minimap: FMinimapData;
+    constructor(flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
+}

package/f-minimap/domain/calculate-flow-point-from-minimap-point/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-flow-point-from-minimap-point.request';
+export * from './calculate-flow-point-from-minimap-point.execution';

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

@@ -0,0 +1,7 @@
+import { IRect } from '@foblex/core';
+export declare class FMinimapData {
+    element: SVGSVGElement;
+    scale: number;
+    viewBox: IRect;
+    constructor(element: SVGSVGElement, scale?: number, viewBox?: IRect);
+}

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

@@ -0,0 +1,21 @@
+import { IPoint, IRect } from '@foblex/core';
+import { FComponentsStore } from '../../f-storage';
+import { EFDraggableType, IDraggableItem } from '../../f-draggable';
+import { FFlowMediator } from '../../infrastructure';
+import { FMinimapData } from './f-minimap-data';
+export declare class FMinimapDragHandler implements IDraggableItem {
+    private fComponentsStore;
+    private fMediator;
+    private flowRect;
+    private canvasPosition;
+    private eventPoint;
+    private minimap;
+    readonly type: EFDraggableType;
+    private lastDifference;
+    constructor(fComponentsStore: FComponentsStore, fMediator: FFlowMediator, flowRect: IRect, canvasPosition: IPoint, eventPoint: IPoint, minimap: FMinimapData);
+    initialize(): void;
+    move(difference: IPoint): void;
+    private isSamePoint;
+    private getNewPosition;
+    complete(): void;
+}

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

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

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

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

package/f-minimap/domain/minimap-drag-finalize/minimap-drag-finalize.execution.d.ts

@@ -0,0 +1,11 @@
+import { MinimapDragFinalizeRequest } from './minimap-drag-finalize.request';
+import { IExecution } from '../../../infrastructure';
+import { FDraggableDataContext } from '../../../f-draggable';
+import * as i0 from "@angular/core";
+export declare class MinimapDragFinalizeExecution implements IExecution<MinimapDragFinalizeRequest, void> {
+    private fDraggableDataContext;
+    constructor(fDraggableDataContext: FDraggableDataContext);
+    handle(request: MinimapDragFinalizeRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragFinalizeExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDragFinalizeExecution>;
+}

package/f-minimap/domain/minimap-drag-finalize/minimap-drag-finalize.request.d.ts

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

package/f-minimap/domain/minimap-drag-finalize/minimap-drag-finalize.validator.d.ts

@@ -0,0 +1,11 @@
+import { MinimapDragFinalizeRequest } from './minimap-drag-finalize.request';
+import { IValidator } from '../../../infrastructure';
+import { FDraggableDataContext } from '../../../f-draggable';
+import * as i0 from "@angular/core";
+export declare class MinimapDragFinalizeValidator implements IValidator<MinimapDragFinalizeRequest> {
+    private fDraggableDataContext;
+    constructor(fDraggableDataContext: FDraggableDataContext);
+    handle(request: MinimapDragFinalizeRequest): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragFinalizeValidator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDragFinalizeValidator>;
+}

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

@@ -0,0 +1,3 @@
+import { MinimapDragFinalizeExecution } from './minimap-drag-finalize.execution';
+import { MinimapDragFinalizeValidator } from './minimap-drag-finalize.validator';
+export declare const MINIMAP_DRAG_FINALIZE_PROVIDERS: (typeof MinimapDragFinalizeExecution | typeof MinimapDragFinalizeValidator)[];

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

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

package/f-minimap/domain/minimap-drag-preparation/minimap-drag-preparation.execution.d.ts

@@ -0,0 +1,17 @@
+import { MinimapDragPreparationRequest } from './minimap-drag-preparation.request';
+import { FFlowMediator, IExecution } from '../../../infrastructure';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../../f-draggable';
+import * as i0 from "@angular/core";
+export declare class MinimapDragPreparationExecution implements IExecution<MinimapDragPreparationRequest, void> {
+    private fComponentsStore;
+    private fMediator;
+    private fDraggableDataContext;
+    private get flowHost();
+    constructor(fComponentsStore: FComponentsStore, fMediator: FFlowMediator, fDraggableDataContext: FDraggableDataContext);
+    handle(request: MinimapDragPreparationRequest): void;
+    private getNewPosition;
+    private getFlowRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragPreparationExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDragPreparationExecution>;
+}

package/f-minimap/domain/minimap-drag-preparation/minimap-drag-preparation.request.d.ts

@@ -0,0 +1,7 @@
+import { IPointerEvent } from '@foblex/core';
+import { FMinimapData } from '../f-minimap-data';
+export declare class MinimapDragPreparationRequest {
+    event: IPointerEvent;
+    minimap: FMinimapData;
+    constructor(event: IPointerEvent, minimap: FMinimapData);
+}

package/f-minimap/domain/minimap-drag-preparation/minimap-drag-preparation.validator.d.ts

@@ -0,0 +1,13 @@
+import { MinimapDragPreparationRequest } from './minimap-drag-preparation.request';
+import { IValidator } from '../../../infrastructure';
+import { FDraggableDataContext } from '../../../f-draggable';
+import { FComponentsStore } from '../../../f-storage';
+import * as i0 from "@angular/core";
+export declare class MinimapDragPreparationValidator implements IValidator<MinimapDragPreparationRequest> {
+    private fComponentsStore;
+    private fDraggableDataContext;
+    constructor(fComponentsStore: FComponentsStore, fDraggableDataContext: FDraggableDataContext);
+    handle(request: MinimapDragPreparationRequest): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDragPreparationValidator, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDragPreparationValidator>;
+}

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

@@ -0,0 +1,3 @@
+import { MinimapDragPreparationExecution } from './minimap-drag-preparation.execution';
+import { MinimapDragPreparationValidator } from './minimap-drag-preparation.validator';
+export declare const MINIMAP_DRAG_PREPARATION_PROVIDERS: (typeof MinimapDragPreparationExecution | typeof MinimapDragPreparationValidator)[];

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

@@ -0,0 +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)[];

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

@@ -0,0 +1,22 @@
+import { ElementRef } from "@angular/core";
+import { FComponentsStore } from '../f-storage';
+import { FFlowMediator } from '../infrastructure';
+import * as i0 from "@angular/core";
+export declare class FMinimapCanvasDirective {
+    private elementReference;
+    private fMediator;
+    private fComponentsStore;
+    get hostElement(): SVGGElement;
+    private get flowHost();
+    private get flowScale();
+    constructor(elementReference: ElementRef<SVGGElement>, fMediator: FFlowMediator, fComponentsStore: FComponentsStore);
+    redraw(): void;
+    private clearCanvas;
+    private renderNode;
+    private configureNodeElement;
+    private getNodeRect;
+    private setElementAttributes;
+    private applyClassList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapCanvasDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapCanvasDirective, "g[fMinimapCanvas]", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,28 @@
+import { ElementRef } from "@angular/core";
+import { FComponentsStore } from '../f-storage';
+import { FFlowMediator } from '../infrastructure';
+import { FMinimapData } from './domain';
+import * as i0 from "@angular/core";
+export declare class FMinimapFlowDirective {
+    private elementReference;
+    private fMediator;
+    private fComponentsStore;
+    model: FMinimapData;
+    fMinSize: number;
+    private get flowHost();
+    get hostElement(): SVGSVGElement;
+    constructor(elementReference: ElementRef<SVGSVGElement>, fMediator: FFlowMediator, fComponentsStore: FComponentsStore);
+    update(): void;
+    private getProcessedNodesRect;
+    private getNodesRect;
+    private getMinimapRect;
+    private normalizeRect;
+    private ensureMinimumSize;
+    private calculateViewScale;
+    private calculateViewBox;
+    private calculateViewSize;
+    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>;
+}

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

@@ -0,0 +1,14 @@
+import { ElementRef } from "@angular/core";
+import { FComponentsStore } from '../f-storage';
+import * as i0 from "@angular/core";
+export declare class FMinimapViewDirective {
+    private elementReference;
+    private fComponentsStore;
+    get hostElement(): SVGRectElement;
+    private get flowScale();
+    constructor(elementReference: ElementRef<SVGRectElement>, fComponentsStore: FComponentsStore);
+    update(): void;
+    private setAttributes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FMinimapViewDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMinimapViewDirective, "rect[fMinimapView]", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,26 @@
+import { AfterViewInit, ElementRef, OnDestroy } from "@angular/core";
+import { FFlowMediator } from '../infrastructure';
+import { FMinimapFlowDirective } from './f-minimap-flow.directive';
+import { FMinimapCanvasDirective } from './f-minimap-canvas.directive';
+import { FMinimapViewDirective } from './f-minimap-view.directive';
+import { IPointerEvent } from '@foblex/core';
+import { IFDragAndDropPlugin } from '../f-draggable';
+import * as i0 from "@angular/core";
+export declare class FMinimapComponent implements AfterViewInit, OnDestroy, IFDragAndDropPlugin {
+    private elementReference;
+    private fMediator;
+    private subscriptions$;
+    fMinimapCanvas: FMinimapCanvasDirective;
+    fMinimapFlow: FMinimapFlowDirective;
+    fMinimapView: FMinimapViewDirective;
+    fMinSize: number;
+    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FFlowMediator);
+    ngAfterViewInit(): void;
+    private subscribeOnTransformChanges;
+    private getTransformChanges;
+    onPointerDown(event: IPointerEvent): void;
+    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>;
+}

package/f-minimap/index.d.ts

@@ -0,0 +1,6 @@
+export * from './domain';
+export * from './f-minimap.component';
+export * from './f-minimap-canvas.directive';
+export * from './f-minimap-view.directive';
+export * from './f-minimap-flow.directive';
+export * from './providers';

package/f-minimap/providers.d.ts

@@ -0,0 +1,5 @@
+import { FMinimapComponent } from './f-minimap.component';
+import { FMinimapViewDirective } from './f-minimap-view.directive';
+import { FMinimapFlowDirective } from './f-minimap-flow.directive';
+import { FMinimapCanvasDirective } from './f-minimap-canvas.directive';
+export declare const F_MINIMAP_PROVIDERS: (typeof FMinimapFlowDirective | typeof FMinimapCanvasDirective | typeof FMinimapViewDirective | typeof FMinimapComponent)[];

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

@@ -3,11 +3,13 @@ import { IHasHostElement, IPoint, IRect, ISize, PointInput } from '@foblex/core'
 import { FNodeBase } from './f-node-base';
 import { FComponentsStore } from '../f-storage';
 import { FConnectorBase } from '../f-connectors';
+import { FFlowMediator } from '../infrastructure';
 import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private elementReference;
     private renderer;
     private fComponentsStore;
+    private fMediator;
     private subscriptions$;
     fId: string;
     set position(value: PointInput);
@@ -21,9 +23,10 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     fConnectOnNode: boolean;
     get hostElement(): HTMLElement;
     connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore);
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FFlowMediator);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
+    redraw(): void;
     ngAfterViewInit(): void;
     private subscribeOnResizeChanges;
     addConnector(connector: FConnectorBase): void;

package/f-storage/f-transform-store.d.ts

@@ -0,0 +1,7 @@
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FTransformStore {
+    readonly changes: Subject<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FTransformStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FTransformStore>;
+}

package/f-storage/index.d.ts

@@ -1 +1,2 @@
 export * from './f-components-store';
+export * from './f-transform-store';

package/{f-canvas/f-zoom → f-zoom}/f-zoom-base.d.ts

@@ -1,6 +1,6 @@
 import { IPoint } from '@foblex/core';
 import { InjectionToken } from '@angular/core';
-import { FComponentsStore } from '../../f-storage';
+import { FComponentsStore } from '../f-storage';
 export declare const F_ZOOM: InjectionToken<FZoomBase>;
 export declare abstract class FZoomBase {
     protected fComponentsStore: FComponentsStore;

package/{f-canvas/f-zoom → f-zoom}/f-zoom.directive.d.ts

@@ -1,6 +1,6 @@
 import { AfterViewInit, OnDestroy } from "@angular/core";
 import { FZoomBase } from './f-zoom-base';
-import { FComponentsStore } from '../../f-storage';
+import { FComponentsStore } from '../f-storage';
 import * as i0 from "@angular/core";
 export declare class FZoomDirective extends FZoomBase implements AfterViewInit, OnDestroy {
     get fFlowZoom(): boolean;

package/{f-canvas/f-zoom → f-zoom}/index.d.ts

@@ -1,2 +1,3 @@
 export * from './f-zoom-base';
 export * from './f-zoom.directive';
+export * from './providers';

package/f-zoom/providers.d.ts

@@ -0,0 +1,2 @@
+import { FZoomDirective } from './f-zoom.directive';
+export declare const F_ZOOM_PROVIDERS: (typeof FZoomDirective)[];