@foblex/flow 12.6.2 → 12.6.4

package/esm2015/f-minimap/f-minimap.component.js

@@ -0,0 +1,76 @@
+import { ChangeDetectionStrategy, Component, Input, ViewChild, } from "@angular/core";
+import { Subscription } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { SubscribeOnTransformChangesRequest } from '../domain';
+import { FMinimapFlowDirective } from './f-minimap-flow.directive';
+import { FMinimapCanvasDirective } from './f-minimap-canvas.directive';
+import { FMinimapViewDirective } from './f-minimap-view.directive';
+import { F_DRAG_AND_DROP_PLUGIN } from '../f-draggable';
+import { MinimapDragFinalizeRequest, MinimapDragPreparationRequest } from './domain';
+import * as i0 from "@angular/core";
+import * as i1 from "@foblex/mediator";
+import * as i2 from "./f-minimap-flow.directive";
+import * as i3 from "./f-minimap-canvas.directive";
+import * as i4 from "./f-minimap-view.directive";
+export class FMinimapComponent {
+    constructor(elementReference, fMediator) {
+        this.elementReference = elementReference;
+        this.fMediator = fMediator;
+        this.subscriptions$ = new Subscription();
+        this.fMinSize = 1000;
+    }
+    ngAfterViewInit() {
+        this.subscriptions$.add(this.subscribeOnTransformChanges());
+    }
+    subscribeOnTransformChanges() {
+        return this.getTransformChanges().pipe(debounceTime(5)).subscribe(() => {
+            this.fMinimapFlow.update();
+            this.fMinimapView.update();
+            this.fMinimapCanvas.redraw();
+        });
+    }
+    getTransformChanges() {
+        return this.fMediator.send(new SubscribeOnTransformChangesRequest());
+    }
+    onPointerDown(event) {
+        this.fMediator.send(new MinimapDragPreparationRequest(event, this.fMinimapFlow.model));
+    }
+    onPointerUp(event) {
+        this.fMediator.send(new MinimapDragFinalizeRequest(event));
+    }
+    ngOnDestroy() {
+        this.subscriptions$.unsubscribe();
+    }
+}
+FMinimapComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FMinimapComponent, deps: [{ token: i0.ElementRef }, { token: i1.FMediator }], target: i0.ɵɵFactoryTarget.Component });
+FMinimapComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FMinimapComponent, selector: "f-minimap", inputs: { fMinSize: "fMinSize" }, host: { classAttribute: "f-component f-minimap" }, providers: [
+        { provide: F_DRAG_AND_DROP_PLUGIN, useExisting: FMinimapComponent },
+    ], viewQueries: [{ propertyName: "fMinimapCanvas", first: true, predicate: FMinimapCanvasDirective, descendants: true, static: true }, { propertyName: "fMinimapFlow", first: true, predicate: FMinimapFlowDirective, descendants: true, static: true }, { propertyName: "fMinimapView", first: true, predicate: FMinimapViewDirective, descendants: true, static: true }], exportAs: ["fComponent"], ngImport: i0, template: "<svg fMinimapFlow width=\"100%\" height=\"100%\" fLockedContext [fMinSize]=\"fMinSize\">\n  <g fMinimapCanvas></g>\n  <rect fMinimapView x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"none\"/>\n</svg>\n\n", styles: [":host{display:block;position:absolute}:host svg{overflow:hidden}\n"], directives: [{ type: i2.FMinimapFlowDirective, selector: "svg[fMinimapFlow]", inputs: ["fMinSize"] }, { type: i3.FMinimapCanvasDirective, selector: "g[fMinimapCanvas]" }, { type: i4.FMinimapViewDirective, selector: "rect[fMinimapView]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FMinimapComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'f-minimap',
+                    templateUrl: './f-minimap.component.html',
+                    styleUrls: ['./f-minimap.component.scss'],
+                    exportAs: 'fComponent',
+                    host: {
+                        'class': 'f-component f-minimap',
+                    },
+                    providers: [
+                        { provide: F_DRAG_AND_DROP_PLUGIN, useExisting: FMinimapComponent },
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FMediator }]; }, propDecorators: { fMinimapCanvas: [{
+                type: ViewChild,
+                args: [FMinimapCanvasDirective, { static: true }]
+            }], fMinimapFlow: [{
+                type: ViewChild,
+                args: [FMinimapFlowDirective, { static: true }]
+            }], fMinimapView: [{
+                type: ViewChild,
+                args: [FMinimapViewDirective, { static: true }]
+            }], fMinSize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-node/f-drag-handle/f-drag-handle.directive.js

@@ -0,0 +1,24 @@
+import { Directive, InjectionToken } from "@angular/core";
+import * as i0 from "@angular/core";
+export const F_DRAG_HANDLE = new InjectionToken('F_DRAG_HANDLE');
+export class FDragHandleDirective {
+    constructor(elementReference) {
+        this.elementReference = elementReference;
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+}
+FDragHandleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FDragHandleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+FDragHandleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FDragHandleDirective, selector: "[fDragHandle]", host: { classAttribute: "f-drag-handle f-component" }, providers: [{ provide: F_DRAG_HANDLE, useExisting: FDragHandleDirective }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FDragHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[fDragHandle]",
+                    host: {
+                        class: "f-drag-handle f-component"
+                    },
+                    providers: [{ provide: F_DRAG_HANDLE, useExisting: FDragHandleDirective }],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1kcmFnLWhhbmRsZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2Ytbm9kZS9mLWRyYWctaGFuZGxlL2YtZHJhZy1oYW5kbGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxTQUFTLEVBQWMsY0FBYyxFQUN0QyxNQUFNLGVBQWUsQ0FBQzs7QUFHdkIsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUF5QyxJQUFJLGNBQWMsQ0FBdUIsZUFBZSxDQUFDLENBQUM7QUFTN0gsTUFBTSxPQUFPLG9CQUFvQjtJQU0vQixZQUNVLGdCQUF5QztRQUF6QyxxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQXlCO0lBRW5ELENBQUM7SUFQRCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsYUFBYSxDQUFDO0lBQzdDLENBQUM7O2tIQUpVLG9CQUFvQjtzR0FBcEIsb0JBQW9CLCtGQUZwQixDQUFFLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxXQUFXLEVBQUUsb0JBQW9CLEVBQUUsQ0FBRTs0RkFFakUsb0JBQW9CO2tCQVBoQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxlQUFlO29CQUN6QixJQUFJLEVBQUU7d0JBQ0osS0FBSyxFQUFFLDJCQUEyQjtxQkFDbkM7b0JBQ0QsU0FBUyxFQUFFLENBQUUsRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLFdBQVcsc0JBQXNCLEVBQUUsQ0FBRTtpQkFDN0UiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEluamVjdGlvblRva2VuXG59IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBJSGFzSG9zdEVsZW1lbnQgfSBmcm9tICcuLi8uLi9pLWhhcy1ob3N0LWVsZW1lbnQnO1xuXG5leHBvcnQgY29uc3QgRl9EUkFHX0hBTkRMRTogSW5qZWN0aW9uVG9rZW48RkRyYWdIYW5kbGVEaXJlY3RpdmU+ID0gbmV3IEluamVjdGlvblRva2VuPEZEcmFnSGFuZGxlRGlyZWN0aXZlPignRl9EUkFHX0hBTkRMRScpO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6IFwiW2ZEcmFnSGFuZGxlXVwiLFxuICBob3N0OiB7XG4gICAgY2xhc3M6IFwiZi1kcmFnLWhhbmRsZSBmLWNvbXBvbmVudFwiXG4gIH0sXG4gIHByb3ZpZGVyczogWyB7IHByb3ZpZGU6IEZfRFJBR19IQU5ETEUsIHVzZUV4aXN0aW5nOiBGRHJhZ0hhbmRsZURpcmVjdGl2ZSB9IF0sXG59KVxuZXhwb3J0IGNsYXNzIEZEcmFnSGFuZGxlRGlyZWN0aXZlIGltcGxlbWVudHMgSUhhc0hvc3RFbGVtZW50IHtcblxuICBwdWJsaWMgZ2V0IGhvc3RFbGVtZW50KCk6IEhUTUxFbGVtZW50IHtcbiAgICByZXR1cm4gdGhpcy5lbGVtZW50UmVmZXJlbmNlLm5hdGl2ZUVsZW1lbnQ7XG4gIH1cblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIGVsZW1lbnRSZWZlcmVuY2U6IEVsZW1lbnRSZWY8SFRNTEVsZW1lbnQ+XG4gICkge1xuICB9XG59XG4iXX0=

package/esm2015/f-node/f-group.directive.js

@@ -0,0 +1,145 @@
+import { Directive, EventEmitter, Input, Output, } from "@angular/core";
+import { PointExtensions } from '@foblex/2d';
+import { F_NODE, FNodeBase } from './f-node-base';
+import { merge, Subscription } from 'rxjs';
+import { startWith, debounceTime } from 'rxjs/operators';
+import { FResizeObserver } from './f-resize-observer';
+import { CalculateConnectorConnectableSideHandler, CalculateConnectorConnectableSideRequest } from '../f-connectors';
+import { EmitTransformChangesRequest } from '../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-storage";
+import * as i2 from "@foblex/mediator";
+import * as i3 from "@foblex/platform";
+let uniqueId = 0;
+export class FGroupDirective extends FNodeBase {
+    constructor(elementReference, renderer, fComponentsStore, fMediator, fBrowser) {
+        super(elementReference.nativeElement);
+        this.renderer = renderer;
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+        this.fBrowser = fBrowser;
+        this.subscriptions$ = new Subscription();
+        this.fId = `f-group-${uniqueId++}`;
+        this.fParentId = null;
+        this.positionChange = new EventEmitter();
+        this.sizeChange = new EventEmitter();
+        this.fDraggingDisabled = false;
+        this.fSelectionDisabled = false;
+        this.fIncludePadding = true;
+        this.fConnectOnNode = true;
+        this.connectors = [];
+    }
+    set position(value) {
+        this._position = PointExtensions.castToPoint(value);
+        this.refresh();
+    }
+    get position() {
+        return this._position;
+    }
+    set size(value) {
+        this._size = value;
+        this.refresh();
+    }
+    get size() {
+        return this._size;
+    }
+    ngOnInit() {
+        this.setStyle('position', 'absolute');
+        this.setStyle('transform-origin', 'center');
+        this.setStyle('user-select', 'none');
+        this.setStyle('pointer-events', 'all');
+        this.setStyle('left', '0');
+        this.setStyle('top', '0');
+        super.redraw();
+        this.fComponentsStore.addComponent(this.fComponentsStore.fNodes, this);
+    }
+    setStyle(styleName, value) {
+        this.renderer.setStyle(this.hostElement, styleName, value);
+    }
+    redraw() {
+        super.redraw();
+        this.fMediator.send(new EmitTransformChangesRequest());
+    }
+    ngAfterViewInit() {
+        if (!this.fBrowser.isBrowser()) {
+            return;
+        }
+        this.subscriptions$.add(this.subscribeOnResizeChanges());
+    }
+    subscribeOnResizeChanges() {
+        return merge(new FResizeObserver(this.hostElement), this.stateChanges).pipe(debounceTime(10), startWith(null)).subscribe(() => {
+            this.connectors.forEach((fConnector) => {
+                fConnector.fConnectableSide = new CalculateConnectorConnectableSideHandler().handle(new CalculateConnectorConnectableSideRequest(fConnector, this.hostElement));
+            });
+            this.fComponentsStore.componentDataChanged();
+        });
+    }
+    addConnector(connector) {
+        this.connectors.push(connector);
+        this.stateChanges.next();
+    }
+    removeConnector(connector) {
+        const index = this.connectors.indexOf(connector);
+        if (index !== -1) {
+            this.connectors.splice(index, 1);
+        }
+        this.stateChanges.next();
+    }
+    refresh() {
+        this.stateChanges.next();
+    }
+    ngOnDestroy() {
+        this.fComponentsStore.removeComponent(this.fComponentsStore.fNodes, this);
+        this.stateChanges.complete();
+        this.subscriptions$.unsubscribe();
+    }
+}
+FGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FGroupDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.FComponentsStore }, { token: i2.FMediator }, { token: i3.BrowserService }], target: i0.ɵɵFactoryTarget.Directive });
+FGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FGroupDirective, selector: "[fGroup]", inputs: { fId: ["fGroupId", "fId"], fParentId: ["fGroupParentId", "fParentId"], position: ["fGroupPosition", "position"], size: ["fGroupSize", "size"], fDraggingDisabled: ["fGroupDraggingDisabled", "fDraggingDisabled"], fSelectionDisabled: ["fGroupSelectionDisabled", "fSelectionDisabled"], fIncludePadding: "fIncludePadding", fConnectOnNode: "fConnectOnNode" }, outputs: { positionChange: "fGroupPositionChange", sizeChange: "fGroupSizeChange" }, host: { properties: { "attr.data-f-group-id": "fId", "class.f-group-dragging-disabled": "fDraggingDisabled", "class.f-group-selection-disabled": "fSelectionDisabled" }, classAttribute: "f-group f-component" }, providers: [
+        { provide: F_NODE, useExisting: FGroupDirective }
+    ], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[fGroup]",
+                    exportAs: "fComponent",
+                    host: {
+                        '[attr.data-f-group-id]': 'fId',
+                        class: "f-group f-component",
+                        '[class.f-group-dragging-disabled]': 'fDraggingDisabled',
+                        '[class.f-group-selection-disabled]': 'fSelectionDisabled',
+                    },
+                    providers: [
+                        { provide: F_NODE, useExisting: FGroupDirective }
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.FComponentsStore }, { type: i2.FMediator }, { type: i3.BrowserService }]; }, propDecorators: { fId: [{
+                type: Input,
+                args: ['fGroupId']
+            }], fParentId: [{
+                type: Input,
+                args: ['fGroupParentId']
+            }], position: [{
+                type: Input,
+                args: ['fGroupPosition']
+            }], positionChange: [{
+                type: Output,
+                args: ['fGroupPositionChange']
+            }], size: [{
+                type: Input,
+                args: ['fGroupSize']
+            }], sizeChange: [{
+                type: Output,
+                args: ['fGroupSizeChange']
+            }], fDraggingDisabled: [{
+                type: Input,
+                args: ['fGroupDraggingDisabled']
+            }], fSelectionDisabled: [{
+                type: Input,
+                args: ['fGroupSelectionDisabled']
+            }], fIncludePadding: [{
+                type: Input
+            }], fConnectOnNode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-group.directive.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-node/f-group.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n} from \"@angular/core\";\nimport { IPoint, IRect, ISize, PointExtensions } from '@foblex/2d';\nimport { F_NODE, FNodeBase } from './f-node-base';\nimport { merge, Subscription } from 'rxjs';\nimport { startWith, debounceTime } from 'rxjs/operators';\nimport { FResizeObserver } from './f-resize-observer';\nimport { FComponentsStore } from '../f-storage';\nimport {\n  CalculateConnectorConnectableSideHandler,\n  CalculateConnectorConnectableSideRequest,\n  FConnectorBase\n} from '../f-connectors';\nimport { FMediator } from '@foblex/mediator';\nimport { EmitTransformChangesRequest } from '../domain';\nimport { BrowserService } from '@foblex/platform';\nimport { IHasHostElement } from '../i-has-host-element';\n\nlet uniqueId: number = 0;\n\n@Directive({\n  selector: \"[fGroup]\",\n  exportAs: \"fComponent\",\n  host: {\n    '[attr.data-f-group-id]': 'fId',\n    class: \"f-group f-component\",\n    '[class.f-group-dragging-disabled]': 'fDraggingDisabled',\n    '[class.f-group-selection-disabled]': 'fSelectionDisabled',\n  },\n  providers: [\n    { provide: F_NODE, useExisting: FGroupDirective }\n  ],\n})\nexport class FGroupDirective extends FNodeBase\n  implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {\n\n  private subscriptions$: Subscription = new Subscription();\n\n  @Input('fGroupId')\n  public override fId: string = `f-group-${ uniqueId++ }`;\n\n  @Input('fGroupParentId')\n  public override fParentId: string | null | undefined = null;\n\n  @Input('fGroupPosition')\n  public override set position(value: IPoint) {\n    this._position = PointExtensions.castToPoint(value);\n    this.refresh();\n  }\n  public override get position(): IPoint {\n    return this._position;\n  }\n  @Output('fGroupPositionChange')\n  public override positionChange: EventEmitter<IPoint> = new EventEmitter<IPoint>();\n\n  @Input('fGroupSize')\n  public override set size(value: ISize) {\n    this._size = value;\n    this.refresh();\n  }\n  public override get size(): ISize {\n    return this._size!;\n  }\n  @Output('fGroupSizeChange')\n  public override sizeChange: EventEmitter<IRect> = new EventEmitter<IRect>();\n\n  @Input('fGroupDraggingDisabled')\n  public override fDraggingDisabled: boolean = false;\n\n  @Input('fGroupSelectionDisabled')\n  public override fSelectionDisabled: boolean = false;\n\n  @Input()\n  public override fIncludePadding: boolean = true;\n\n  @Input()\n  public override fConnectOnNode: boolean = true;\n\n  public override connectors: FConnectorBase[] = [];\n\n  constructor(\n    elementReference: ElementRef<HTMLElement>,\n    private renderer: Renderer2,\n    private fComponentsStore: FComponentsStore,\n    private fMediator: FMediator,\n    private fBrowser: BrowserService\n  ) {\n    super(elementReference.nativeElement);\n  }\n\n  public ngOnInit(): void {\n    this.setStyle('position', 'absolute');\n    this.setStyle('transform-origin', 'center');\n    this.setStyle('user-select', 'none');\n    this.setStyle('pointer-events', 'all');\n    this.setStyle('left', '0');\n    this.setStyle('top', '0');\n    super.redraw();\n    this.fComponentsStore.addComponent(this.fComponentsStore.fNodes, this);\n  }\n\n  protected override setStyle(styleName: string, value: string) {\n    this.renderer.setStyle(this.hostElement, styleName, value);\n  }\n\n  public override redraw(): void {\n    super.redraw();\n    this.fMediator.send(new EmitTransformChangesRequest());\n  }\n\n  public ngAfterViewInit(): void {\n    if(!this.fBrowser.isBrowser()) {\n      return;\n    }\n    this.subscriptions$.add(\n      this.subscribeOnResizeChanges()\n    );\n  }\n\n  private subscribeOnResizeChanges(): Subscription {\n    return merge(new FResizeObserver(this.hostElement as HTMLElement), this.stateChanges).pipe(\n      debounceTime(10), startWith(null)\n    ).subscribe(() => {\n      this.connectors.forEach((fConnector: FConnectorBase) => {\n        fConnector.fConnectableSide = new CalculateConnectorConnectableSideHandler().handle(\n          new CalculateConnectorConnectableSideRequest(fConnector, this.hostElement)\n        );\n      });\n      this.fComponentsStore.componentDataChanged();\n    });\n  }\n\n  public override addConnector(connector: FConnectorBase): void {\n    this.connectors.push(connector);\n    this.stateChanges.next();\n  }\n\n  public override removeConnector(connector: FConnectorBase): void {\n    const index = this.connectors.indexOf(connector);\n    if (index !== -1) {\n      this.connectors.splice(index, 1);\n    }\n    this.stateChanges.next();\n  }\n\n  public refresh(): void {\n    this.stateChanges.next();\n  }\n\n  public ngOnDestroy(): void {\n    this.fComponentsStore.removeComponent(this.fComponentsStore.fNodes, this);\n    this.stateChanges.complete();\n    this.subscriptions$.unsubscribe();\n  }\n}\n"]}

package/esm2015/f-node/f-node-base.js

@@ -0,0 +1,35 @@
+import { InjectionToken } from '@angular/core';
+import { Subject } from 'rxjs';
+import { PointExtensions } from '@foblex/2d';
+import { mixinChangeSelection } from '../mixins';
+export const F_NODE = new InjectionToken('F_NODE');
+const MIXIN_BASE = mixinChangeSelection(class {
+    constructor(hostElement) {
+        this.hostElement = hostElement;
+    }
+});
+export class FNodeBase extends MIXIN_BASE {
+    constructor() {
+        super(...arguments);
+        this.stateChanges = new Subject();
+        this._position = PointExtensions.initialize();
+        this.fCanBeResizedByChild = true;
+    }
+    isContains(element) {
+        return this.hostElement.contains(element);
+    }
+    redraw() {
+        if (this.size) {
+            this.setStyle('width', '' + this.size.width + 'px');
+            this.setStyle('height', '' + this.size.height + 'px');
+        }
+        this.setStyle('transform', `translate(${this.position.x}px,${this.position.y}px)`);
+    }
+    updatePosition(position) {
+        this._position = position;
+    }
+    updateSize(value) {
+        this._size = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-node/f-node.directive.js

@@ -0,0 +1,146 @@
+import { Directive, EventEmitter, Input, Output, } from "@angular/core";
+import { PointExtensions } from '@foblex/2d';
+import { merge, Subscription } from 'rxjs';
+import { startWith, debounceTime } from 'rxjs/operators';
+import { FResizeObserver } from './f-resize-observer';
+import { CalculateConnectorConnectableSideHandler, CalculateConnectorConnectableSideRequest } from '../f-connectors';
+import { EmitTransformChangesRequest } from '../domain';
+import { F_NODE, FNodeBase } from './f-node-base';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-storage";
+import * as i2 from "@foblex/mediator";
+import * as i3 from "@foblex/platform";
+let uniqueId = 0;
+export class FNodeDirective extends FNodeBase {
+    constructor(elementReference, renderer, fComponentsStore, fMediator, fBrowser) {
+        super(elementReference.nativeElement);
+        this.renderer = renderer;
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+        this.fBrowser = fBrowser;
+        this.subscriptions$ = new Subscription();
+        this.fId = `f-node-${uniqueId++}`;
+        this.fParentId = null;
+        this.positionChange = new EventEmitter();
+        this.sizeChange = new EventEmitter();
+        this.fDraggingDisabled = false;
+        this.fSelectionDisabled = false;
+        this.fIncludePadding = true;
+        //TODO: Add ability to connect to first connectable input if node is under pointer
+        this.fConnectOnNode = true;
+        this.connectors = [];
+    }
+    set position(value) {
+        this._position = PointExtensions.castToPoint(value);
+        this.refresh();
+    }
+    get position() {
+        return this._position;
+    }
+    set size(value) {
+        this._size = value;
+        this.refresh();
+    }
+    get size() {
+        return this._size;
+    }
+    ngOnInit() {
+        this.setStyle('position', 'absolute');
+        this.setStyle('transform-origin', 'center');
+        this.setStyle('user-select', 'none');
+        this.setStyle('pointer-events', 'all');
+        this.setStyle('left', '0');
+        this.setStyle('top', '0');
+        super.redraw();
+        this.fComponentsStore.addComponent(this.fComponentsStore.fNodes, this);
+    }
+    setStyle(styleName, value) {
+        this.renderer.setStyle(this.hostElement, styleName, value);
+    }
+    redraw() {
+        super.redraw();
+        this.fMediator.send(new EmitTransformChangesRequest());
+    }
+    ngAfterViewInit() {
+        if (!this.fBrowser.isBrowser()) {
+            return;
+        }
+        this.subscriptions$.add(this.subscribeOnResizeChanges());
+    }
+    subscribeOnResizeChanges() {
+        return merge(new FResizeObserver(this.hostElement), this.stateChanges).pipe(debounceTime(10), startWith(null)).subscribe(() => {
+            this.connectors.forEach((fConnector) => {
+                fConnector.fConnectableSide = new CalculateConnectorConnectableSideHandler().handle(new CalculateConnectorConnectableSideRequest(fConnector, this.hostElement));
+            });
+            this.fComponentsStore.componentDataChanged();
+        });
+    }
+    addConnector(connector) {
+        this.connectors.push(connector);
+        this.stateChanges.next();
+    }
+    removeConnector(connector) {
+        const index = this.connectors.indexOf(connector);
+        if (index !== -1) {
+            this.connectors.splice(index, 1);
+        }
+        this.stateChanges.next();
+    }
+    refresh() {
+        this.stateChanges.next();
+    }
+    ngOnDestroy() {
+        this.fComponentsStore.removeComponent(this.fComponentsStore.fNodes, this);
+        this.stateChanges.complete();
+        this.subscriptions$.unsubscribe();
+    }
+}
+FNodeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FNodeDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.FComponentsStore }, { token: i2.FMediator }, { token: i3.BrowserService }], target: i0.ɵɵFactoryTarget.Directive });
+FNodeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FNodeDirective, selector: "[fNode]", inputs: { fId: ["fNodeId", "fId"], fParentId: ["fNodeParentId", "fParentId"], position: ["fNodePosition", "position"], size: ["fNodeSize", "size"], fDraggingDisabled: ["fNodeDraggingDisabled", "fDraggingDisabled"], fSelectionDisabled: ["fNodeSelectionDisabled", "fSelectionDisabled"], fIncludePadding: "fIncludePadding", fConnectOnNode: "fConnectOnNode" }, outputs: { positionChange: "fNodePositionChange", sizeChange: "fNodeSizeChange" }, host: { properties: { "attr.data-f-node-id": "fId", "class.f-node-dragging-disabled": "fDraggingDisabled", "class.f-node-selection-disabled": "fSelectionDisabled" }, classAttribute: "f-node f-component" }, providers: [
+        { provide: F_NODE, useExisting: FNodeDirective }
+    ], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FNodeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[fNode]",
+                    exportAs: "fComponent",
+                    host: {
+                        '[attr.data-f-node-id]': 'fId',
+                        class: "f-node f-component",
+                        '[class.f-node-dragging-disabled]': 'fDraggingDisabled',
+                        '[class.f-node-selection-disabled]': 'fSelectionDisabled',
+                    },
+                    providers: [
+                        { provide: F_NODE, useExisting: FNodeDirective }
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.FComponentsStore }, { type: i2.FMediator }, { type: i3.BrowserService }]; }, propDecorators: { fId: [{
+                type: Input,
+                args: ['fNodeId']
+            }], fParentId: [{
+                type: Input,
+                args: ['fNodeParentId']
+            }], position: [{
+                type: Input,
+                args: ['fNodePosition']
+            }], positionChange: [{
+                type: Output,
+                args: ['fNodePositionChange']
+            }], size: [{
+                type: Input,
+                args: ['fNodeSize']
+            }], sizeChange: [{
+                type: Output,
+                args: ['fNodeSizeChange']
+            }], fDraggingDisabled: [{
+                type: Input,
+                args: ['fNodeDraggingDisabled']
+            }], fSelectionDisabled: [{
+                type: Input,
+                args: ['fNodeSelectionDisabled']
+            }], fIncludePadding: [{
+                type: Input
+            }], fConnectOnNode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-node.directive.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-node/f-node.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n} from \"@angular/core\";\nimport { IPoint, IRect, ISize, PointExtensions } from '@foblex/2d';\nimport { BrowserService } from '@foblex/platform';\nimport { merge, Subscription } from 'rxjs';\nimport { startWith, debounceTime } from 'rxjs/operators';\nimport { FResizeObserver } from './f-resize-observer';\nimport { FComponentsStore } from '../f-storage';\nimport {\n  CalculateConnectorConnectableSideHandler,\n  CalculateConnectorConnectableSideRequest,\n  FConnectorBase\n} from '../f-connectors';\nimport { FMediator } from '@foblex/mediator';\nimport { EmitTransformChangesRequest } from '../domain';\nimport { F_NODE, FNodeBase } from './f-node-base';\nimport { IHasHostElement } from '../i-has-host-element';\n\nlet uniqueId: number = 0;\n\n@Directive({\n  selector: \"[fNode]\",\n  exportAs: \"fComponent\",\n  host: {\n    '[attr.data-f-node-id]': 'fId',\n    class: \"f-node f-component\",\n    '[class.f-node-dragging-disabled]': 'fDraggingDisabled',\n    '[class.f-node-selection-disabled]': 'fSelectionDisabled',\n  },\n  providers: [\n    { provide: F_NODE, useExisting: FNodeDirective }\n  ],\n})\nexport class FNodeDirective extends FNodeBase implements OnInit, AfterViewInit, IHasHostElement, OnDestroy {\n\n  private subscriptions$: Subscription = new Subscription();\n\n  @Input('fNodeId')\n  public override fId: string = `f-node-${ uniqueId++ }`;\n\n  @Input('fNodeParentId')\n  public override fParentId: string | null | undefined = null;\n\n  @Input('fNodePosition')\n  public override set position(value: IPoint) {\n    this._position = PointExtensions.castToPoint(value);\n    this.refresh();\n  }\n\n  public override get position(): IPoint {\n    return this._position;\n  }\n\n  @Output('fNodePositionChange')\n  public override positionChange: EventEmitter<IPoint> = new EventEmitter<IPoint>();\n\n  @Input('fNodeSize')\n  public override set size(value: ISize) {\n    this._size = value;\n    this.refresh();\n  }\n\n  public override get size(): ISize {\n    return this._size!;\n  }\n\n  @Output('fNodeSizeChange')\n  public override sizeChange: EventEmitter<IRect> = new EventEmitter<IRect>();\n\n  @Input('fNodeDraggingDisabled')\n  public override fDraggingDisabled: boolean = false;\n\n  @Input('fNodeSelectionDisabled')\n  public override fSelectionDisabled: boolean = false;\n\n  @Input()\n  public override fIncludePadding: boolean = true;\n\n  //TODO: Add ability to connect to first connectable input if node is under pointer\n  @Input()\n  public override fConnectOnNode: boolean = true;\n\n  public override connectors: FConnectorBase[] = [];\n\n  constructor(\n    elementReference: ElementRef<HTMLElement>,\n    private renderer: Renderer2,\n    private fComponentsStore: FComponentsStore,\n    private fMediator: FMediator,\n    private fBrowser: BrowserService\n  ) {\n    super(elementReference.nativeElement);\n  }\n\n  public ngOnInit(): void {\n    this.setStyle('position', 'absolute');\n    this.setStyle('transform-origin', 'center');\n    this.setStyle('user-select', 'none');\n    this.setStyle('pointer-events', 'all');\n    this.setStyle('left', '0');\n    this.setStyle('top', '0');\n    super.redraw();\n    this.fComponentsStore.addComponent(this.fComponentsStore.fNodes, this);\n  }\n\n  protected override setStyle(styleName: string, value: string) {\n    this.renderer.setStyle(this.hostElement, styleName, value);\n  }\n\n  public override redraw(): void {\n    super.redraw();\n    this.fMediator.send(new EmitTransformChangesRequest());\n  }\n\n  public ngAfterViewInit(): void {\n    if(!this.fBrowser.isBrowser()) {\n      return;\n    }\n    this.subscriptions$.add(\n      this.subscribeOnResizeChanges()\n    );\n  }\n\n  private subscribeOnResizeChanges(): Subscription {\n    return merge(new FResizeObserver(this.hostElement as HTMLElement), this.stateChanges).pipe(\n      debounceTime(10), startWith(null)\n    ).subscribe(() => {\n      this.connectors.forEach((fConnector: FConnectorBase) => {\n        fConnector.fConnectableSide = new CalculateConnectorConnectableSideHandler().handle(\n          new CalculateConnectorConnectableSideRequest(fConnector, this.hostElement)\n        );\n      });\n      this.fComponentsStore.componentDataChanged();\n    });\n  }\n\n  public override addConnector(connector: FConnectorBase): void {\n    this.connectors.push(connector);\n    this.stateChanges.next();\n  }\n\n  public override removeConnector(connector: FConnectorBase): void {\n    const index = this.connectors.indexOf(connector);\n    if (index !== -1) {\n      this.connectors.splice(index, 1);\n    }\n    this.stateChanges.next();\n  }\n\n  public refresh(): void {\n    this.stateChanges.next();\n  }\n\n  public ngOnDestroy(): void {\n    this.fComponentsStore.removeComponent(this.fComponentsStore.fNodes, this);\n    this.stateChanges.complete();\n    this.subscriptions$.unsubscribe();\n  }\n}\n"]}

package/esm2015/f-node/f-resize-handle/f-resize-handle.directive.js

@@ -0,0 +1,43 @@
+import { Directive, HostBinding, InjectionToken, Input } from "@angular/core";
+import { EFResizeHandleType } from './e-f-resize-handle-type';
+import { castToEnum } from '@foblex/utils';
+import * as i0 from "@angular/core";
+export const F_RESIZE_HANDLE = new InjectionToken('F_RESIZE_HANDLE');
+export class FResizeHandleDirective {
+    constructor(elementReference) {
+        this.elementReference = elementReference;
+        this._type = EFResizeHandleType.LEFT_TOP;
+    }
+    set type(type) {
+        this._type = castToEnum(type, 'fResizeHandleType', EFResizeHandleType);
+    }
+    get type() {
+        return this._type;
+    }
+    get typeClass() {
+        return `f-resize-handle-${EFResizeHandleType[this.type.toUpperCase()]}`;
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+}
+FResizeHandleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FResizeHandleDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+FResizeHandleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FResizeHandleDirective, selector: "[fResizeHandle]", inputs: { type: ["fResizeHandleType", "type"] }, host: { properties: { "attr.data-f-resize-handle-type": "type", "class": "this.typeClass" }, classAttribute: "f-resize-handle f-component" }, providers: [{ provide: F_RESIZE_HANDLE, useExisting: FResizeHandleDirective }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FResizeHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[fResizeHandle]",
+                    host: {
+                        class: `f-resize-handle f-component`,
+                        '[attr.data-f-resize-handle-type]': 'type',
+                    },
+                    providers: [{ provide: F_RESIZE_HANDLE, useExisting: FResizeHandleDirective }],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { type: [{
+                type: Input,
+                args: ['fResizeHandleType']
+            }], typeClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-node/f-rotate-handle/f-rotate-handle.directive.js

@@ -0,0 +1,27 @@
+// export const F_ROTATE_HANDLE: InjectionToken<FRotateHandleDirective> = new InjectionToken<FRotateHandleDirective>('F_ROTATE_HANDLE');
+//
+// @Directive({
+//   selector: "[fRotateHandle]",
+//   host: {
+//     class: `f-rotate-handle f-component`,
+//     '[class.f-rotate-handle-disabled]': 'disabled',
+//   },
+//   providers: [ { provide: F_ROTATE_HANDLE, useExisting: FRotateHandleDirective } ],
+// })
+export class FRotateHandleDirective {
+    constructor(elementReference) {
+        this.elementReference = elementReference;
+        this.isDisabled = false;
+    }
+    // @Input('fRotateHandleDisabled')
+    // public set disabled(isDisabled: boolean | undefined | string) {
+    //   this.isDisabled = BooleanExtensions.castToBoolean(isDisabled);
+    // }
+    get disabled() {
+        return this.isDisabled;
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1yb3RhdGUtaGFuZGxlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1ub2RlL2Ytcm90YXRlLWhhbmRsZS9mLXJvdGF0ZS1oYW5kbGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLHdJQUF3STtBQUN4SSxFQUFFO0FBQ0YsZUFBZTtBQUNmLGlDQUFpQztBQUNqQyxZQUFZO0FBQ1osNENBQTRDO0FBQzVDLHNEQUFzRDtBQUN0RCxPQUFPO0FBQ1Asc0ZBQXNGO0FBQ3RGLEtBQUs7QUFDTCxNQUFNLE9BQU8sc0JBQXNCO0lBZWpDLFlBQ1UsZ0JBQXlDO1FBQXpDLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBeUI7UUFkM0MsZUFBVSxHQUFZLEtBQUssQ0FBQztJQWdCcEMsQ0FBQztJQWZELGtDQUFrQztJQUNsQyxrRUFBa0U7SUFDbEUsbUVBQW1FO0lBQ25FLElBQUk7SUFDSixJQUFXLFFBQVE7UUFDakIsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDO0lBQ3pCLENBQUM7SUFFRCxJQUFXLFdBQVc7UUFDcEIsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsYUFBYSxDQUFDO0lBQzdDLENBQUM7Q0FNRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSW5qZWN0aW9uVG9rZW4sIElucHV0XG59IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBJSGFzSG9zdEVsZW1lbnQgfSBmcm9tICcuLi8uLi9pLWhhcy1ob3N0LWVsZW1lbnQnO1xuXG4vLyBleHBvcnQgY29uc3QgRl9ST1RBVEVfSEFORExFOiBJbmplY3Rpb25Ub2tlbjxGUm90YXRlSGFuZGxlRGlyZWN0aXZlPiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGUm90YXRlSGFuZGxlRGlyZWN0aXZlPignRl9ST1RBVEVfSEFORExFJyk7XG4vL1xuLy8gQERpcmVjdGl2ZSh7XG4vLyAgIHNlbGVjdG9yOiBcIltmUm90YXRlSGFuZGxlXVwiLFxuLy8gICBob3N0OiB7XG4vLyAgICAgY2xhc3M6IGBmLXJvdGF0ZS1oYW5kbGUgZi1jb21wb25lbnRgLFxuLy8gICAgICdbY2xhc3MuZi1yb3RhdGUtaGFuZGxlLWRpc2FibGVkXSc6ICdkaXNhYmxlZCcsXG4vLyAgIH0sXG4vLyAgIHByb3ZpZGVyczogWyB7IHByb3ZpZGU6IEZfUk9UQVRFX0hBTkRMRSwgdXNlRXhpc3Rpbmc6IEZSb3RhdGVIYW5kbGVEaXJlY3RpdmUgfSBdLFxuLy8gfSlcbmV4cG9ydCBjbGFzcyBGUm90YXRlSGFuZGxlRGlyZWN0aXZlIGltcGxlbWVudHMgSUhhc0hvc3RFbGVtZW50IHtcblxuICBwcml2YXRlIGlzRGlzYWJsZWQ6IGJvb2xlYW4gPSBmYWxzZTtcbiAgLy8gQElucHV0KCdmUm90YXRlSGFuZGxlRGlzYWJsZWQnKVxuICAvLyBwdWJsaWMgc2V0IGRpc2FibGVkKGlzRGlzYWJsZWQ6IGJvb2xlYW4gfCB1bmRlZmluZWQgfCBzdHJpbmcpIHtcbiAgLy8gICB0aGlzLmlzRGlzYWJsZWQgPSBCb29sZWFuRXh0ZW5zaW9ucy5jYXN0VG9Cb29sZWFuKGlzRGlzYWJsZWQpO1xuICAvLyB9XG4gIHB1YmxpYyBnZXQgZGlzYWJsZWQoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuaXNEaXNhYmxlZDtcbiAgfVxuXG4gIHB1YmxpYyBnZXQgaG9zdEVsZW1lbnQoKTogSFRNTEVsZW1lbnQge1xuICAgIHJldHVybiB0aGlzLmVsZW1lbnRSZWZlcmVuY2UubmF0aXZlRWxlbWVudDtcbiAgfVxuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgZWxlbWVudFJlZmVyZW5jZTogRWxlbWVudFJlZjxIVE1MRWxlbWVudD5cbiAgKSB7XG4gIH1cbn1cbiJdfQ==

package/esm2015/f-selection-area/domain/selection-area-finalize/selection-area-finalize.execution.js

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { SelectionAreaFinalizeRequest } from './selection-area-finalize.request';
+import { FExecutionRegister } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../f-draggable";
+let SelectionAreaFinalizeExecution = class SelectionAreaFinalizeExecution {
+    constructor(fDraggableDataContext) {
+        this.fDraggableDataContext = fDraggableDataContext;
+    }
+    handle(request) {
+        this.fDraggableDataContext.draggableItems.forEach((x) => {
+            var _a;
+            (_a = x.complete) === null || _a === void 0 ? void 0 : _a.call(x);
+        });
+    }
+};
+SelectionAreaFinalizeExecution.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectionAreaFinalizeExecution, deps: [{ token: i1.FDraggableDataContext }], target: i0.ɵɵFactoryTarget.Injectable });
+SelectionAreaFinalizeExecution.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectionAreaFinalizeExecution });
+SelectionAreaFinalizeExecution = __decorate([
+    FExecutionRegister(SelectionAreaFinalizeRequest)
+], SelectionAreaFinalizeExecution);
+export { SelectionAreaFinalizeExecution };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectionAreaFinalizeExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FDraggableDataContext }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLWFyZWEtZmluYWxpemUuZXhlY3V0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLXNlbGVjdGlvbi1hcmVhL2RvbWFpbi9zZWxlY3Rpb24tYXJlYS1maW5hbGl6ZS9zZWxlY3Rpb24tYXJlYS1maW5hbGl6ZS5leGVjdXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDakYsT0FBTyxFQUFFLGtCQUFrQixFQUFjLE1BQU0sa0JBQWtCLENBQUM7OztJQUtyRCw4QkFBOEIsU0FBOUIsOEJBQThCO0lBRXpDLFlBQ1UscUJBQTRDO1FBQTVDLDBCQUFxQixHQUFyQixxQkFBcUIsQ0FBdUI7SUFFdEQsQ0FBQztJQUVNLE1BQU0sQ0FBQyxPQUFxQztRQUNqRCxJQUFJLENBQUMscUJBQXFCLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFOztZQUN0RCxNQUFBLENBQUMsQ0FBQyxRQUFRLCtDQUFWLENBQUMsQ0FBYSxDQUFDO1FBQ2pCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGLENBQUE7NEhBWlksOEJBQThCO2dJQUE5Qiw4QkFBOEI7QUFBOUIsOEJBQThCO0lBRDFDLGtCQUFrQixDQUFDLDRCQUE0QixDQUFDO0dBQ3BDLDhCQUE4QixDQVkxQztTQVpZLDhCQUE4Qjs0RkFBOUIsOEJBQThCO2tCQUYxQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU2VsZWN0aW9uQXJlYUZpbmFsaXplUmVxdWVzdCB9IGZyb20gJy4vc2VsZWN0aW9uLWFyZWEtZmluYWxpemUucmVxdWVzdCc7XG5pbXBvcnQgeyBGRXhlY3V0aW9uUmVnaXN0ZXIsIElFeGVjdXRpb24gfSBmcm9tICdAZm9ibGV4L21lZGlhdG9yJztcbmltcG9ydCB7IEZEcmFnZ2FibGVEYXRhQ29udGV4dCB9IGZyb20gJy4uLy4uLy4uL2YtZHJhZ2dhYmxlJztcblxuQEluamVjdGFibGUoKVxuQEZFeGVjdXRpb25SZWdpc3RlcihTZWxlY3Rpb25BcmVhRmluYWxpemVSZXF1ZXN0KVxuZXhwb3J0IGNsYXNzIFNlbGVjdGlvbkFyZWFGaW5hbGl6ZUV4ZWN1dGlvbiBpbXBsZW1lbnRzIElFeGVjdXRpb248U2VsZWN0aW9uQXJlYUZpbmFsaXplUmVxdWVzdCwgdm9pZD4ge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgZkRyYWdnYWJsZURhdGFDb250ZXh0OiBGRHJhZ2dhYmxlRGF0YUNvbnRleHQsXG4gICkge1xuICB9XG5cbiAgcHVibGljIGhhbmRsZShyZXF1ZXN0OiBTZWxlY3Rpb25BcmVhRmluYWxpemVSZXF1ZXN0KTogdm9pZCB7XG4gICAgdGhpcy5mRHJhZ2dhYmxlRGF0YUNvbnRleHQuZHJhZ2dhYmxlSXRlbXMuZm9yRWFjaCgoeCkgPT4ge1xuICAgICAgeC5jb21wbGV0ZT8uKCk7XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2015/f-selection-area/domain/selection-area-finalize/selection-area-finalize.request.js

@@ -0,0 +1,6 @@
+export class SelectionAreaFinalizeRequest {
+    constructor(event) {
+        this.event = event;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0aW9uLWFyZWEtZmluYWxpemUucmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1zZWxlY3Rpb24tYXJlYS9kb21haW4vc2VsZWN0aW9uLWFyZWEtZmluYWxpemUvc2VsZWN0aW9uLWFyZWEtZmluYWxpemUucmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sNEJBQTRCO0lBRXZDLFlBQ1MsS0FBb0I7UUFBcEIsVUFBSyxHQUFMLEtBQUssQ0FBZTtJQUU3QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnRlckV2ZW50IH0gZnJvbSAnQGZvYmxleC9kcmFnLXRvb2xraXQnO1xuXG5leHBvcnQgY2xhc3MgU2VsZWN0aW9uQXJlYUZpbmFsaXplUmVxdWVzdCB7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHVibGljIGV2ZW50OiBJUG9pbnRlckV2ZW50XG4gICkge1xuICB9XG59XG4iXX0=