@foblex/flow 17.0.0 → 17.0.2

package/f-minimap/domain/minimap-calculate-svg-scale-and-view-box/minimap-calculate-svg-scale-and-view-box.execution.d.ts

@@ -0,0 +1,22 @@
+import { MinimapCalculateSvgScaleAndViewBoxRequest } from './minimap-calculate-svg-scale-and-view-box.request';
+import { IExecution } from '@foblex/mediator';
+import { IFMinimapScaleAndViewBox } from './i-f-minimap-scale-and-view-box';
+import * as i0 from "@angular/core";
+export declare class MinimapCalculateSvgScaleAndViewBoxExecution implements IExecution<MinimapCalculateSvgScaleAndViewBoxRequest, IFMinimapScaleAndViewBox> {
+    private _fMediator;
+    private _fComponentStore;
+    private get _fFlow();
+    private get _fCanvas();
+    handle(request: MinimapCalculateSvgScaleAndViewBoxRequest): IFMinimapScaleAndViewBox;
+    private _getScaledNodesBoundingBox;
+    private _calculateNodesBoundingBox;
+    private _convertFromGlobalToFlowRect;
+    private _convertRectToMinimapScale;
+    private _getMinimapRect;
+    private _calculateViewScale;
+    private _calculateViewBox;
+    private _calculateViewSize;
+    private _calculateCenteredViewBox;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapCalculateSvgScaleAndViewBoxExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapCalculateSvgScaleAndViewBoxExecution>;
+}

package/f-minimap/domain/minimap-calculate-svg-scale-and-view-box/minimap-calculate-svg-scale-and-view-box.request.d.ts

@@ -0,0 +1,5 @@
+export declare class MinimapCalculateSvgScaleAndViewBoxRequest {
+    element: SVGSVGElement;
+    minSize: number;
+    constructor(element: SVGSVGElement, minSize: number);
+}

package/f-minimap/domain/minimap-calculate-view-box/index.d.ts

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

package/f-minimap/domain/minimap-calculate-view-box/minimap-calculate-view-box.execution.d.ts

@@ -0,0 +1,14 @@
+import { MinimapCalculateViewBoxRequest } from './minimap-calculate-view-box.request';
+import { IExecution } from '@foblex/mediator';
+import { IRect } from '@foblex/2d';
+import * as i0 from "@angular/core";
+export declare class MinimapCalculateViewBoxExecution implements IExecution<MinimapCalculateViewBoxRequest, IRect> {
+    private _fComponentStore;
+    private get _fFlow();
+    private get _fCanvas();
+    handle(request: MinimapCalculateViewBoxRequest): IRect;
+    private _getRectForMinimapView;
+    private _calculateViewBox;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapCalculateViewBoxExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapCalculateViewBoxExecution>;
+}

package/f-minimap/domain/minimap-calculate-view-box/minimap-calculate-view-box.request.d.ts

@@ -0,0 +1,2 @@
+export declare class MinimapCalculateViewBoxRequest {
+}

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

@@ -0,0 +1,2 @@
+export * from './minimap-draw-nodes.execution';
+export * from './minimap-draw-nodes.request';

package/f-minimap/domain/minimap-draw-nodes/minimap-draw-nodes.execution.d.ts

@@ -0,0 +1,18 @@
+import { MinimapDrawNodesRequest } from './minimap-draw-nodes.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class MinimapDrawNodesExecution implements IExecution<MinimapDrawNodesRequest, SVGRectElement[]> {
+    private _fBrowser;
+    private _fComponentStore;
+    private get _fFlow();
+    private get _fNodes();
+    private get _fCanvas();
+    handle(request: MinimapDrawNodesRequest): SVGRectElement[];
+    private _createMinimapNodeElements;
+    private _createNodeElement;
+    private _getNodeRect;
+    private _getNodeRectInFlow;
+    private _applyClassList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapDrawNodesExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MinimapDrawNodesExecution>;
+}

package/f-minimap/domain/minimap-draw-nodes/minimap-draw-nodes.request.d.ts

@@ -0,0 +1,2 @@
+export declare class MinimapDrawNodesRequest {
+}

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

@@ -1,2 +1,5 @@
 import { CalculateFlowPointFromMinimapPointExecution } from './calculate-flow-point-from-minimap-point';
-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)[];
+import { MinimapDrawNodesExecution } from './minimap-draw-nodes';
+import { MinimapCalculateViewBoxExecution } from './minimap-calculate-view-box';
+import { MinimapCalculateSvgScaleAndViewBoxExecution } from './minimap-calculate-svg-scale-and-view-box';
+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 | typeof MinimapDrawNodesExecution | typeof MinimapCalculateViewBoxExecution | typeof MinimapCalculateSvgScaleAndViewBoxExecution)[];

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

@@ -1,22 +1,10 @@
-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;
+    private _fMediator;
+    private _elementReference;
     get hostElement(): SVGGElement;
-    private get flowHost();
-    private get flowScale();
-    constructor(elementReference: ElementRef<SVGGElement>, fComponentsStore: FComponentsStore, fBrowser: BrowserService);
     redraw(): void;
-    private clearCanvas;
-    private renderNode;
-    private configureNodeElement;
-    private getNodeRect;
-    private setElementAttributes;
-    private applyClassList;
+    private _clearCanvas;
     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

@@ -1,28 +1,12 @@
-import { ElementRef } from "@angular/core";
-import { FComponentsStore } from '../f-storage';
-import { FMediator } from '@foblex/mediator';
 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();
+    private _fMediator;
+    private _elementReference;
     get hostElement(): SVGSVGElement;
-    constructor(elementReference: ElementRef<SVGSVGElement>, fMediator: FMediator, fComponentsStore: FComponentsStore);
-    update(): void;
-    private getProcessedNodesRect;
-    private getNodesRect;
-    private getMinimapRect;
-    private normalizeRect;
-    private ensureMinimumSize;
-    private calculateViewScale;
-    private calculateViewBox;
-    private calculateViewSize;
-    private calculateCenteredViewBox;
-    private setViewBox;
+    model: FMinimapData;
+    redraw(): void;
     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

@@ -1,14 +1,9 @@
-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;
+    private _fMediator;
+    private _elementReference;
+    get hostElement(): SVGGElement;
+    redraw(): void;
     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

@@ -1,26 +1,23 @@
-import { AfterViewInit, ElementRef, OnDestroy } from "@angular/core";
-import { FMediator } from '@foblex/mediator';
+import { AfterViewInit } from "@angular/core";
 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/drag-toolkit';
 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$;
+export declare class FMinimapComponent implements AfterViewInit, IFDragAndDropPlugin {
+    private _destroyRef;
+    private _fMediator;
+    private _fBrowser;
     fMinimapCanvas: FMinimapCanvasDirective;
     fMinimapFlow: FMinimapFlowDirective;
     fMinimapView: FMinimapViewDirective;
     fMinSize: number;
-    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FMediator);
     ngAfterViewInit(): void;
-    private subscribeOnTransformChanges;
-    private getTransformChanges;
+    private _listenTransformChanges;
+    private _redraw;
     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-node/domain/index.d.ts

@@ -1,2 +1 @@
-export * from './is-group';
 export * from './is-node';

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

@@ -1,11 +1,10 @@
-import { ElementRef, InjectionToken } from "@angular/core";
+import { InjectionToken } from "@angular/core";
 import { IHasHostElement } from '../../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_DRAG_HANDLE: InjectionToken<FDragHandleDirective>;
 export declare class FDragHandleDirective implements IHasHostElement {
-    private elementReference;
+    private _elementReference;
     get hostElement(): HTMLElement;
-    constructor(elementReference: ElementRef<HTMLElement>);
     static ɵfac: i0.ɵɵFactoryDeclaration<FDragHandleDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FDragHandleDirective, "[fDragHandle]", never, {}, {}, never, never, false, never>;
 }

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

@@ -1,18 +1,12 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
 import { IPoint, IRect, ISize } from '@foblex/2d';
 import { FNodeBase } from './f-node-base';
-import { FComponentsStore } from '../f-storage';
-import { FConnectorBase } from '../f-connectors';
-import { FMediator } from '@foblex/mediator';
 import { BrowserService } from '@foblex/platform';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FGroupDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private renderer;
-    private fComponentsStore;
-    private fMediator;
     private fBrowser;
-    private subscriptions$;
     fId: string;
     fParentId: string | null | undefined;
     set position(value: IPoint);
@@ -25,15 +19,14 @@ export declare class FGroupDirective extends FNodeBase implements OnInit, AfterV
     fSelectionDisabled: boolean;
     fIncludePadding: boolean;
     fConnectOnNode: boolean;
-    connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
+    private _destroyRef;
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
     ngAfterViewInit(): void;
-    private subscribeOnResizeChanges;
-    addConnector(connector: FConnectorBase): void;
-    removeConnector(connector: FConnectorBase): void;
+    private _listenStateSizeChanges;
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FGroupDirective, never>;

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

@@ -1,20 +1,19 @@
 import { EventEmitter, InjectionToken } from '@angular/core';
-import { Subject } from 'rxjs';
 import { IPoint, IRect, ISize } from '@foblex/2d';
-import { IHasStateChanges } from '../i-has-state-changes';
 import { FConnectorBase } from '../f-connectors';
 import { IHasHostElement } from '../i-has-host-element';
 import { ICanChangeSelection } from '../mixins';
+import { FChannel } from '../reactivity';
 export declare const F_NODE: InjectionToken<FNodeBase>;
 declare const MIXIN_BASE: import("../mixins").Constructor<ICanChangeSelection> & import("../mixins").AbstractConstructor<ICanChangeSelection> & {
     new (hostElement: HTMLElement): {
         hostElement: HTMLElement;
     };
 };
-export declare abstract class FNodeBase extends MIXIN_BASE implements IHasStateChanges, ICanChangeSelection, IHasHostElement {
+export declare abstract class FNodeBase extends MIXIN_BASE implements ICanChangeSelection, IHasHostElement {
     abstract fId: string;
     abstract fParentId: string | null | undefined;
-    readonly stateChanges: Subject<void>;
+    readonly stateChanges: FChannel;
     abstract positionChange: EventEmitter<IPoint>;
     abstract position: IPoint;
     protected _position: IPoint;
@@ -27,9 +26,7 @@ export declare abstract class FNodeBase extends MIXIN_BASE implements IHasStateC
     fCanBeResizedByChild: boolean;
     abstract fIncludePadding: boolean;
     abstract refresh(): void;
-    abstract connectors: FConnectorBase[];
-    abstract addConnector(connector: FConnectorBase): void;
-    abstract removeConnector(connector: FConnectorBase): void;
+    connectors: FConnectorBase[];
     protected abstract setStyle(name: string, value: string): void;
     isContains(element: HTMLElement | SVGElement): boolean;
     redraw(): void;
@@ -37,5 +34,7 @@ export declare abstract class FNodeBase extends MIXIN_BASE implements IHasStateC
     updateSize(value: ISize): void;
     setClass(className: string): void;
     removeClass(className: string): void;
+    addConnector(connector: FConnectorBase): void;
+    removeConnector(connector: FConnectorBase): void;
 }
 export {};

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

@@ -1,18 +1,12 @@
 import { AfterViewInit, ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from "@angular/core";
 import { IPoint, IRect, ISize } from '@foblex/2d';
 import { BrowserService } from '@foblex/platform';
-import { FComponentsStore } from '../f-storage';
-import { FConnectorBase } from '../f-connectors';
-import { FMediator } from '@foblex/mediator';
 import { FNodeBase } from './f-node-base';
 import { IHasHostElement } from '../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {
     private renderer;
-    private fComponentsStore;
-    private fMediator;
     private fBrowser;
-    private subscriptions$;
     fId: string;
     fParentId: string | null | undefined;
     set position(value: IPoint);
@@ -25,15 +19,14 @@ export declare class FNodeDirective extends FNodeBase implements OnInit, AfterVi
     fSelectionDisabled: boolean;
     fIncludePadding: boolean;
     fConnectOnNode: boolean;
-    connectors: FConnectorBase[];
-    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fComponentsStore: FComponentsStore, fMediator: FMediator, fBrowser: BrowserService);
+    private _destroyRef;
+    private _fMediator;
+    constructor(elementReference: ElementRef<HTMLElement>, renderer: Renderer2, fBrowser: BrowserService);
     ngOnInit(): void;
     protected setStyle(styleName: string, value: string): void;
     redraw(): void;
     ngAfterViewInit(): void;
-    private subscribeOnResizeChanges;
-    addConnector(connector: FConnectorBase): void;
-    removeConnector(connector: FConnectorBase): void;
+    private _listenStateSizeChanges;
     refresh(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeDirective, never>;

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

@@ -1,16 +1,14 @@
-import { ElementRef, InjectionToken } from "@angular/core";
+import { InjectionToken } from "@angular/core";
 import { EFResizeHandleType } from './e-f-resize-handle-type';
 import { IHasHostElement } from '../../i-has-host-element';
 import * as i0 from "@angular/core";
 export declare const F_RESIZE_HANDLE: InjectionToken<FResizeHandleDirective>;
 export declare class FResizeHandleDirective implements IHasHostElement {
-    private elementReference;
-    _type: EFResizeHandleType;
-    set type(type: EFResizeHandleType);
-    get type(): EFResizeHandleType;
+    private _elementReference;
+    type: EFResizeHandleType;
     get typeClass(): string;
     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 ngAcceptInputType_type: unknown;
 }

package/f-node/index.d.ts

@@ -5,5 +5,4 @@ export * from './f-rotate-handle';
 export * from './f-group.directive';
 export * from './f-node.directive';
 export * from './f-node-base';
-export * from './f-resize-observer';
 export * from './providers';

package/f-selection-area/domain/selection-area.drag-handle.d.ts

@@ -12,7 +12,7 @@ export declare class SelectionAreaDragHandle implements IDraggableItem {
     private selectedByMove;
     private get canvasPosition();
     constructor(fComponentsStore: FComponentsStore, fSelectionArea: FSelectionAreaBase, fDraggableDataContext: FDraggableDataContext, fMediator: FMediator);
-    initialize(): void;
-    move(difference: IPoint): void;
-    complete(): void;
+    prepareDragSequence(): void;
+    onPointerMove(difference: IPoint): void;
+    onPointerUp(): void;
 }

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

@@ -1,15 +1,13 @@
-import { ElementRef, OnInit } from '@angular/core';
+import { OnInit } from '@angular/core';
 import { FSelectionAreaBase } from './f-selection-area-base';
 import { IFDragAndDropPlugin } from '../f-draggable';
 import { IPointerEvent } from '@foblex/drag-toolkit';
 import { IRect } from '@foblex/2d';
-import { FMediator } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FSelectionAreaComponent extends FSelectionAreaBase implements OnInit, IFDragAndDropPlugin {
-    private elementReference;
-    private fMediator;
+    private _fMediator;
+    private _elementReference;
     get hostElement(): HTMLElement;
-    constructor(elementReference: ElementRef<HTMLElement>, fMediator: FMediator);
     ngOnInit(): void;
     hide(): void;
     show(): void;

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

@@ -1,5 +1,3 @@
-import { Observable } from 'rxjs';
-import { ITransformModel } from '@foblex/2d';
 import { FConnectionBase, FMarkerBase } from '../f-connection';
 import { FFlowBase } from '../f-flow';
 import { FCanvasBase } from '../f-canvas';
@@ -7,14 +5,13 @@ import { FBackgroundBase } from '../f-backgroud';
 import { FNodeBase } from '../f-node';
 import { FConnectorBase } from '../f-connectors';
 import { FDraggableBase } from '../f-draggable';
+import { FChannel } from '../reactivity';
 import * as i0 from "@angular/core";
 export declare class FComponentsStore {
-    private readonly componentsDataChanges;
-    get componentsData$(): Observable<void>;
-    private readonly componentsCountChanges;
-    get componentsCount$(): Observable<void>;
+    readonly transformChanges$: FChannel;
+    readonly dataChanges$: FChannel;
+    readonly countChanges$: FChannel;
     get flowHost(): HTMLElement;
-    get transform(): ITransformModel;
     fFlow: FFlowBase | undefined;
     fCanvas: FCanvasBase | undefined;
     fBackground: FBackgroundBase | undefined;
@@ -27,10 +24,11 @@ export declare class FComponentsStore {
     fInputs: FConnectorBase[];
     fOutlets: FConnectorBase[];
     fDraggable: FDraggableBase | undefined;
-    findNode(element: HTMLElement | SVGElement): FNodeBase | undefined;
     addComponent<T>(collection: T[], component: T): void;
     removeComponent<T>(collection: T[], component: T): void;
-    componentDataChanged(): void;
+    countChanged(): void;
+    dataChanged(): void;
+    transformChanged(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FComponentsStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FComponentsStore>;
 }

package/f-storage/features/listen-components-data-changed/index.d.ts

@@ -0,0 +1,2 @@
+export * from './listen-data-changes.execution';
+export * from './listen-data-changes-request';

package/f-storage/features/listen-components-data-changed/listen-data-changes-request.d.ts

@@ -0,0 +1,2 @@
+export declare class ListenDataChangesRequest {
+}

package/f-storage/features/listen-components-data-changed/listen-data-changes.execution.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { ListenDataChangesRequest } from './listen-data-changes-request';
+import { FChannelHub } from '../../../reactivity';
+import * as i0 from "@angular/core";
+export declare class ListenDataChangesExecution implements IExecution<ListenDataChangesRequest, FChannelHub> {
+    private _fComponentsStore;
+    handle(request: ListenDataChangesRequest): FChannelHub;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenDataChangesExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListenDataChangesExecution>;
+}

package/f-storage/features/listen-count-changes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './listen-count-changes.execution';
+export * from './listen-count-changes-request';

package/f-storage/features/listen-count-changes/listen-count-changes-request.d.ts

@@ -0,0 +1,2 @@
+export declare class ListenCountChangesRequest {
+}

package/f-storage/features/listen-count-changes/listen-count-changes.execution.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { ListenCountChangesRequest } from './listen-count-changes-request';
+import { FChannelHub } from '../../../reactivity';
+import * as i0 from "@angular/core";
+export declare class ListenCountChangesExecution implements IExecution<ListenCountChangesRequest, FChannelHub> {
+    private _fComponentsStore;
+    handle(request: ListenCountChangesRequest): FChannelHub;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenCountChangesExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListenCountChangesExecution>;
+}

package/f-storage/features/listen-transform-changes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './listen-transform-changes.execution';
+export * from './listen-transform-changes.request';

package/f-storage/features/listen-transform-changes/listen-transform-changes.execution.d.ts

@@ -0,0 +1,10 @@
+import { ListenTransformChangesRequest } from './listen-transform-changes.request';
+import { IExecution } from '@foblex/mediator';
+import { FChannelHub } from '../../../reactivity';
+import * as i0 from "@angular/core";
+export declare class ListenTransformChangesExecution implements IExecution<ListenTransformChangesRequest, FChannelHub> {
+    private _fComponentsStore;
+    handle(request: ListenTransformChangesRequest): FChannelHub;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListenTransformChangesExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ListenTransformChangesExecution>;
+}

package/f-storage/features/listen-transform-changes/listen-transform-changes.request.d.ts

@@ -0,0 +1,2 @@
+export declare class ListenTransformChangesRequest {
+}

package/f-storage/features/notify-data-changed/index.d.ts

@@ -0,0 +1,2 @@
+export * from './notify-data-changed.execution';
+export * from './notify-data-changed-request';

package/f-storage/features/notify-data-changed/notify-data-changed-request.d.ts

@@ -0,0 +1,2 @@
+export declare class NotifyDataChangedRequest {
+}

package/f-storage/features/notify-data-changed/notify-data-changed.execution.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { NotifyDataChangedRequest } from './notify-data-changed-request';
+import * as i0 from "@angular/core";
+export declare class NotifyDataChangedExecution implements IExecution<NotifyDataChangedRequest, void> {
+    private _fComponentsStore;
+    handle(request: NotifyDataChangedRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotifyDataChangedExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotifyDataChangedExecution>;
+}

package/f-storage/features/notify-transform-changed/index.d.ts

@@ -0,0 +1,2 @@
+export * from './notify-transform-changed.execution';
+export * from './notify-transform-changed.request';

package/f-storage/features/notify-transform-changed/notify-transform-changed.execution.d.ts

@@ -0,0 +1,9 @@
+import { NotifyTransformChangedRequest } from './notify-transform-changed.request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class NotifyTransformChangedExecution implements IExecution<NotifyTransformChangedRequest, void> {
+    private _fComponentsStore;
+    handle(request: NotifyTransformChangedRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotifyTransformChangedExecution, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotifyTransformChangedExecution>;
+}

package/f-storage/features/notify-transform-changed/notify-transform-changed.request.d.ts

@@ -0,0 +1,2 @@
+export declare class NotifyTransformChangedRequest {
+}

package/f-storage/index.d.ts

@@ -1,2 +1,7 @@
+export * from './features/notify-data-changed';
+export * from './features/listen-components-data-changed';
+export * from './features/listen-count-changes';
+export * from './features/listen-transform-changes';
+export * from './features/notify-transform-changed';
 export * from './f-components-store';
-export * from './f-transform-store';
+export * from './providers';

package/f-storage/providers.d.ts

@@ -0,0 +1,7 @@
+import { NotifyDataChangedExecution } from './features/notify-data-changed';
+import { ListenDataChangesExecution } from './features/listen-components-data-changed';
+import { FComponentsStore } from './f-components-store';
+import { ListenCountChangesExecution } from './features/listen-count-changes';
+import { ListenTransformChangesExecution } from './features/listen-transform-changes';
+import { NotifyTransformChangedExecution } from './features/notify-transform-changed';
+export declare const F_STORAGE_PROVIDERS: (typeof NotifyDataChangedExecution | typeof FComponentsStore | typeof ListenDataChangesExecution | typeof ListenCountChangesExecution | typeof ListenTransformChangesExecution | typeof NotifyTransformChangedExecution)[];

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

@@ -1,26 +1,25 @@
 import { IPoint } from '@foblex/2d';
 import { InjectionToken } from '@angular/core';
-import { FComponentsStore } from '../f-storage';
 export declare const F_ZOOM: InjectionToken<FZoomBase>;
 export declare abstract class FZoomBase {
-    protected fComponentsStore: FComponentsStore;
     protected isEnabled: boolean;
     abstract minimum: number;
     abstract maximum: number;
     abstract step: number;
     abstract dblClickStep: number;
-    private listeners;
-    private get flowHost();
-    private get fCanvas();
-    protected constructor(fComponentsStore: FComponentsStore);
+    private _listeners;
+    private _fMediator;
+    private get _fFlowHostElement();
+    private get _fCanvas();
+    private get _isDragStarted();
     protected toggleZoom(): void;
-    private subscribe;
+    private _subscribe;
     getScale(): number;
-    private onWheel;
-    private onDoubleClick;
-    private onZoomToCenter;
+    private _onWheel;
+    private _onDoubleClick;
+    private _onZoomToCenter;
     zoomIn(position?: IPoint): void;
     zoomOut(position?: IPoint): void;
     reset(): void;
-    protected unsubscribe(): void;
+    protected dispose(): void;
 }

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

@@ -1,6 +1,5 @@
 import { AfterViewInit, OnDestroy } from "@angular/core";
 import { FZoomBase } from './f-zoom-base';
-import { FComponentsStore } from '../f-storage';
 import * as i0 from "@angular/core";
 export declare class FZoomDirective extends FZoomBase implements AfterViewInit, OnDestroy {
     get fFlowZoom(): boolean;
@@ -9,7 +8,6 @@ export declare class FZoomDirective extends FZoomBase implements AfterViewInit,
     maximum: number;
     step: number;
     dblClickStep: number;
-    constructor(fComponentsStore: FComponentsStore);
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FZoomDirective, never>;