@foblex/flow 12.4.0 → 12.5.1

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-drag-handle/f-drag-handle.directive.d.ts

@@ -4,11 +4,8 @@ import * as i0 from "@angular/core";
 export declare const F_DRAG_HANDLE: InjectionToken<FDragHandleDirective>;
 export declare class FDragHandleDirective implements IHasHostElement {
     private elementReference;
-    get disabled(): boolean;
-    set disabled(isDisabled: boolean | undefined | string);
-    private isDisabled;
     get hostElement(): HTMLElement;
     constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, { "disabled": { "alias": "fDragHandleDisabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
 }

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-node/f-resize-handle/f-resize-handle.directive.d.ts

@@ -5,9 +5,6 @@ import * as i0 from "@angular/core";
 export declare const F_RESIZE_HANDLE: InjectionToken<FResizeHandleDirective>;
 export declare class FResizeHandleDirective implements IHasHostElement {
     private elementReference;
-    private isDisabled;
-    set disabled(isDisabled: boolean | undefined | string);
-    get disabled(): boolean;
     _type: EFResizeHandleType;
     set type(type: EFResizeHandleType);
     get type(): EFResizeHandleType;
@@ -15,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, { "disabled": { "alias": "fResizeHandleDisabled"; "required": false; }; "type": { "alias": "fResizeHandleType"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FResizeHandleDirective, "[fResizeHandle]", never, { "type": { "alias": "fResizeHandleType"; "required": false; }; }, {}, never, never, false, never>;
 }

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)[];