@foblex/flow 12.6.2 → 12.6.4

package/esm2015/f-external-item/f-external-item.service.js

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FExternalItemService {
+    constructor() {
+        this.items = [];
+    }
+    registerItem(item) {
+        this.items.push(item);
+    }
+    getItem(element) {
+        return this.items.find(item => item.hostElement === element);
+    }
+    removeItem(item) {
+        const index = this.items.indexOf(item);
+        if (index !== -1) {
+            this.items.splice(index, 1);
+        }
+    }
+}
+FExternalItemService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FExternalItemService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FExternalItemService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FExternalItemService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FExternalItemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1leHRlcm5hbC1pdGVtLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZXh0ZXJuYWwtaXRlbS9mLWV4dGVybmFsLWl0ZW0uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU0zQyxNQUFNLE9BQU8sb0JBQW9CO0lBSGpDO1FBS1UsVUFBSyxHQUF3QixFQUFFLENBQUM7S0FnQnpDO0lBZFEsWUFBWSxDQUFDLElBQXVCO1FBQ3pDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3hCLENBQUM7SUFFTSxPQUFPLENBQUMsT0FBaUM7UUFDOUMsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxXQUFXLEtBQUssT0FBTyxDQUFDLENBQUM7SUFDL0QsQ0FBQztJQUVNLFVBQVUsQ0FBQyxJQUF1QjtRQUN2QyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2QyxJQUFJLEtBQUssS0FBSyxDQUFDLENBQUMsRUFBRTtZQUNoQixJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7U0FDN0I7SUFDSCxDQUFDOztrSEFqQlUsb0JBQW9CO3NIQUFwQixvQkFBb0IsY0FGbkIsTUFBTTs0RkFFUCxvQkFBb0I7a0JBSGhDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRkV4dGVybmFsSXRlbUJhc2UgfSBmcm9tICcuL2YtZXh0ZXJuYWwtaXRlbS1iYXNlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgRkV4dGVybmFsSXRlbVNlcnZpY2Uge1xuXG4gIHByaXZhdGUgaXRlbXM6IEZFeHRlcm5hbEl0ZW1CYXNlW10gPSBbXTtcblxuICBwdWJsaWMgcmVnaXN0ZXJJdGVtKGl0ZW06IEZFeHRlcm5hbEl0ZW1CYXNlKTogdm9pZCB7XG4gICAgdGhpcy5pdGVtcy5wdXNoKGl0ZW0pO1xuICB9XG5cbiAgcHVibGljIGdldEl0ZW0oZWxlbWVudDogSFRNTEVsZW1lbnQgfCBTVkdFbGVtZW50KTogRkV4dGVybmFsSXRlbUJhc2UgfCB1bmRlZmluZWQge1xuICAgIHJldHVybiB0aGlzLml0ZW1zLmZpbmQoaXRlbSA9PiBpdGVtLmhvc3RFbGVtZW50ID09PSBlbGVtZW50KTtcbiAgfVxuXG4gIHB1YmxpYyByZW1vdmVJdGVtKGl0ZW06IEZFeHRlcm5hbEl0ZW1CYXNlKTogdm9pZCB7XG4gICAgY29uc3QgaW5kZXggPSB0aGlzLml0ZW1zLmluZGV4T2YoaXRlbSk7XG4gICAgaWYgKGluZGV4ICE9PSAtMSkge1xuICAgICAgdGhpcy5pdGVtcy5zcGxpY2UoaW5kZXgsIDEpO1xuICAgIH1cbiAgfVxufVxuIl19

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

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+export const F_FLOW = new InjectionToken('F_FLOW');
+export class FFlowBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mbG93LWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZmxvdy9mLWZsb3ctYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWdCLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUc3RCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxjQUFjLENBQVksUUFBUSxDQUFDLENBQUM7QUFFOUQsTUFBTSxPQUFnQixTQUFTO0NBTzlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyLCBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSUhhc0hvc3RFbGVtZW50IH0gZnJvbSAnLi4vaS1oYXMtaG9zdC1lbGVtZW50JztcblxuZXhwb3J0IGNvbnN0IEZfRkxPVyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGRmxvd0Jhc2U+KCdGX0ZMT1cnKTtcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZGbG93QmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGZGbG93SWQ6IHN0cmluZztcblxuICBwdWJsaWMgYWJzdHJhY3QgaG9zdEVsZW1lbnQ6IEhUTUxFbGVtZW50O1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBmTG9hZGVkOiBFdmVudEVtaXR0ZXI8dm9pZD47XG59XG4iXX0=

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

@@ -0,0 +1,124 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output } from '@angular/core';
+import { F_FLOW, FFlowBase } from './f-flow-base';
+import { Subscription } from 'rxjs';
+import { startWith, debounceTime } from 'rxjs/operators';
+import { ClearSelectionRequest, COMMON_PROVIDERS, GetScaledNodeRectsWithFlowPositionRequest, GetPositionInFlowRequest, GetSelectionRequest, RedrawConnectionsRequest, SelectAllRequest, SelectRequest, SortItemLayersRequest, GetFlowStateRequest, ShowConnectionsAfterCalculationsRequest, } from '../domain';
+import { FMediator } from '@foblex/mediator';
+import { F_DRAGGABLE_PROVIDERS, FDraggableDataContext } from '../f-draggable';
+import { FConnectionFactory } from '../f-connection';
+import { FComponentsStore, FTransformStore } from '../f-storage';
+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 FFlowComponent extends FFlowBase {
+    constructor(elementReference, fComponentsStore, fMediator, fBrowser) {
+        super();
+        this.elementReference = elementReference;
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+        this.fBrowser = fBrowser;
+        this.subscription$ = new Subscription();
+        this.fFlowId = `f-flow-${uniqueId++}`;
+        this.fLoaded = new EventEmitter();
+        this.isLoaded = false;
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    ngOnInit() {
+        this.fComponentsStore.fFlow = this;
+    }
+    ngAfterContentInit() {
+        if (!this.fBrowser.isBrowser()) {
+            return;
+        }
+        this.subscription$.add(this.subscribeOnElementsChanges());
+        this.subscription$.add(this.subscribeOnComponentsCountChanges());
+    }
+    subscribeOnComponentsCountChanges() {
+        return this.fComponentsStore.componentsCount$.pipe(startWith(null), debounceTime(20)).subscribe(() => {
+            this.fMediator.send(new SortItemLayersRequest());
+        });
+    }
+    subscribeOnElementsChanges() {
+        return this.fComponentsStore.componentsData$.pipe(startWith(null), debounceTime(20)).subscribe(() => {
+            this.fMediator.send(new RedrawConnectionsRequest());
+            if (!this.isLoaded) {
+                this.fMediator.send(new ShowConnectionsAfterCalculationsRequest());
+                this.isLoaded = true;
+                this.fLoaded.emit();
+            }
+        });
+    }
+    redraw() {
+        this.fComponentsStore.componentDataChanged();
+    }
+    reset() {
+        this.isLoaded = false;
+    }
+    getAllNodesRect() {
+        return this.fMediator.send(new GetScaledNodeRectsWithFlowPositionRequest());
+    }
+    getSelection() {
+        return this.fMediator.send(new GetSelectionRequest());
+    }
+    getPositionInFlow(position) {
+        return this.fMediator.send(new GetPositionInFlowRequest(position));
+    }
+    getState() {
+        return this.fMediator.send(new GetFlowStateRequest());
+    }
+    selectAll() {
+        this.fMediator.send(new SelectAllRequest());
+    }
+    select(nodes, connections) {
+        this.fMediator.send(new SelectRequest(nodes, connections));
+    }
+    clearSelection() {
+        this.fMediator.send(new ClearSelectionRequest());
+    }
+    ngOnDestroy() {
+        this.subscription$.unsubscribe();
+    }
+}
+FFlowComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FFlowComponent, deps: [{ token: i0.ElementRef }, { token: i1.FComponentsStore }, { token: i2.FMediator }, { token: i3.BrowserService }], target: i0.ɵɵFactoryTarget.Component });
+FFlowComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FFlowComponent, selector: "f-flow", inputs: { fFlowId: "fFlowId" }, outputs: { fLoaded: "fLoaded" }, host: { properties: { "attr.id": "fFlowId" }, classAttribute: "f-component f-flow" }, providers: [
+        FMediator,
+        FComponentsStore,
+        FTransformStore,
+        FDraggableDataContext,
+        FConnectionFactory,
+        ...F_DRAGGABLE_PROVIDERS,
+        ...COMMON_PROVIDERS,
+        { provide: F_FLOW, useExisting: FFlowComponent },
+    ], usesInheritance: true, ngImport: i0, template: "<ng-container>\n  <ng-content select=\"[fDefinitions]\"></ng-content>\n\n  <ng-content select=\"f-background\"></ng-content>\n\n  <ng-content select=\"f-line-alignment\"></ng-content>\n\n  <ng-content select=\"f-canvas\"></ng-content>\n\n  <ng-content select=\"f-selection-area\"></ng-content>\n\n  <ng-content select=\"f-minimap\"></ng-content>\n</ng-container>\n", styles: [":host{display:block;position:relative;width:100%;height:100%;overflow:hidden;pointer-events:all;-webkit-user-select:none;user-select:none;touch-action:none}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FFlowComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'f-flow',
+                    templateUrl: './f-flow.component.html',
+                    styleUrls: ['./f-flow.component.scss'],
+                    host: {
+                        '[attr.id]': 'fFlowId',
+                        class: "f-component f-flow",
+                    },
+                    providers: [
+                        FMediator,
+                        FComponentsStore,
+                        FTransformStore,
+                        FDraggableDataContext,
+                        FConnectionFactory,
+                        ...F_DRAGGABLE_PROVIDERS,
+                        ...COMMON_PROVIDERS,
+                        { provide: F_FLOW, useExisting: FFlowComponent },
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FComponentsStore }, { type: i2.FMediator }, { type: i3.BrowserService }]; }, propDecorators: { fFlowId: [{
+                type: Input
+            }], fLoaded: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-flow.component.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-flow/f-flow.component.ts","../../../../projects/f-flow/src/f-flow/f-flow.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component, ElementRef, EventEmitter,\n  Input, OnDestroy, OnInit, Output\n} from '@angular/core';\nimport { F_FLOW, FFlowBase } from './f-flow-base';\nimport { Subscription } from 'rxjs';\nimport { startWith, debounceTime } from 'rxjs/operators';\nimport {\n  ClearSelectionRequest,\n  COMMON_PROVIDERS,\n  GetScaledNodeRectsWithFlowPositionRequest,\n  GetPositionInFlowRequest,\n  GetSelectionRequest,\n  RedrawConnectionsRequest,\n  SelectAllRequest,\n  SelectRequest,\n  SortItemLayersRequest,\n  IFFlowState,\n  GetFlowStateRequest,\n  ShowConnectionsAfterCalculationsRequest,\n} from '../domain';\nimport { IPoint, IRect } from '@foblex/2d';\nimport { FMediator } from '@foblex/mediator';\nimport {\n  F_DRAGGABLE_PROVIDERS,\n  FDraggableDataContext, FSelectionChangeEvent\n} from '../f-draggable';\nimport { FConnectionFactory } from '../f-connection';\nimport { FComponentsStore, FTransformStore } from '../f-storage';\nimport { BrowserService } from '@foblex/platform';\n\nlet uniqueId: number = 0;\n\n@Component({\n  selector: 'f-flow',\n  templateUrl: './f-flow.component.html',\n  styleUrls: [ './f-flow.component.scss' ],\n  host: {\n    '[attr.id]': 'fFlowId',\n    class: \"f-component f-flow\",\n  },\n  providers: [\n    FMediator,\n    FComponentsStore,\n    FTransformStore,\n    FDraggableDataContext,\n    FConnectionFactory,\n    ...F_DRAGGABLE_PROVIDERS,\n    ...COMMON_PROVIDERS,\n    { provide: F_FLOW, useExisting: FFlowComponent },\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FFlowComponent extends FFlowBase implements OnInit, AfterContentInit, OnDestroy {\n\n  private subscription$: Subscription = new Subscription();\n\n  @Input()\n  public override fFlowId: string = `f-flow-${ uniqueId++ }`;\n\n  public override get hostElement(): HTMLElement {\n    return this.elementReference.nativeElement;\n  }\n\n  @Output()\n  public override fLoaded: EventEmitter<void> = new EventEmitter<void>();\n\n  private isLoaded: boolean = false;\n\n  constructor(\n    private elementReference: ElementRef<HTMLElement>,\n    private fComponentsStore: FComponentsStore,\n    private fMediator: FMediator,\n    private fBrowser: BrowserService,\n  ) {\n    super();\n  }\n\n  public ngOnInit(): void {\n    this.fComponentsStore.fFlow = this;\n  }\n\n  public ngAfterContentInit(): void {\n    if(!this.fBrowser.isBrowser()) {\n      return;\n    }\n    this.subscription$.add(\n      this.subscribeOnElementsChanges()\n    );\n    this.subscription$.add(\n      this.subscribeOnComponentsCountChanges()\n    );\n  }\n\n  private subscribeOnComponentsCountChanges(): Subscription {\n    return this.fComponentsStore.componentsCount$.pipe(startWith(null), debounceTime(20)).subscribe(() => {\n      this.fMediator.send(new SortItemLayersRequest());\n    });\n  }\n\n  private subscribeOnElementsChanges(): Subscription {\n    return this.fComponentsStore.componentsData$.pipe(startWith(null), debounceTime(20)).subscribe(() => {\n      this.fMediator.send(new RedrawConnectionsRequest());\n\n      if (!this.isLoaded) {\n        this.fMediator.send(new ShowConnectionsAfterCalculationsRequest());\n        this.isLoaded = true;\n        this.fLoaded.emit();\n      }\n    });\n  }\n\n  public redraw(): void {\n    this.fComponentsStore.componentDataChanged();\n  }\n\n  public reset(): void {\n    this.isLoaded = false;\n  }\n\n  public getAllNodesRect(): IRect | null {\n    return this.fMediator.send<IRect | null>(new GetScaledNodeRectsWithFlowPositionRequest());\n  }\n\n  public getSelection(): FSelectionChangeEvent {\n    return this.fMediator.send<FSelectionChangeEvent>(new GetSelectionRequest());\n  }\n\n  public getPositionInFlow(position: IPoint): IRect {\n    return this.fMediator.send(new GetPositionInFlowRequest(position));\n  }\n\n  public getState(): IFFlowState {\n    return this.fMediator.send(new GetFlowStateRequest());\n  }\n\n  public selectAll(): void {\n    this.fMediator.send<void>(new SelectAllRequest());\n  }\n\n  public select(nodes: string[], connections: string[]): void {\n    this.fMediator.send<void>(new SelectRequest(nodes, connections));\n  }\n\n  public clearSelection(): void {\n    this.fMediator.send<void>(new ClearSelectionRequest());\n  }\n\n  public ngOnDestroy(): void {\n    this.subscription$.unsubscribe();\n  }\n}\n","<ng-container>\n  <ng-content select=\"[fDefinitions]\"></ng-content>\n\n  <ng-content select=\"f-background\"></ng-content>\n\n  <ng-content select=\"f-line-alignment\"></ng-content>\n\n  <ng-content select=\"f-canvas\"></ng-content>\n\n  <ng-content select=\"f-selection-area\"></ng-content>\n\n  <ng-content select=\"f-minimap\"></ng-content>\n</ng-container>\n"]}

package/esm2015/f-flow.module.js

@@ -0,0 +1,89 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { F_CONNECTION_PROVIDERS, } from './f-connection';
+import { F_NODE_PROVIDERS } from './f-node';
+import { F_FLOW_PROVIDERS } from './f-flow';
+import { F_BACKGROUND_PROVIDERS } from './f-backgroud';
+import { F_CANVAS_PROVIDERS } from './f-canvas';
+import { F_CONNECTORS_PROVIDERS } from './f-connectors';
+import { FDraggableDirective } from './f-draggable';
+import { F_EXTERNAL_ITEM_PROVIDERS } from './f-external-item';
+import { F_SELECTION_AREA_PROVIDERS } from './f-selection-area';
+import { F_LINE_ALIGNMENT_PROVIDERS } from './f-line-alignment';
+import { F_MINIMAP_PROVIDERS } from './f-minimap';
+import { F_ZOOM_PROVIDERS } from './f-zoom';
+import * as i0 from "@angular/core";
+import * as i1 from "./f-backgroud/f-background.component";
+import * as i2 from "./f-backgroud/f-rect-pattern/f-rect-pattern.component";
+import * as i3 from "./f-backgroud/f-circle-pattern/f-circle-pattern.component";
+import * as i4 from "./f-canvas/f-canvas.component";
+import * as i5 from "./f-zoom/f-zoom.directive";
+import * as i6 from "./f-connection/common/f-connection-text/f-connection-text.component";
+import * as i7 from "./f-connection/common/f-connection-text/f-connection-text-path.directive";
+import * as i8 from "./f-connection/common/f-drag-handle/f-connection-drag-handle.component";
+import * as i9 from "./f-connection/common/f-gradient/f-connection-gradient.component";
+import * as i10 from "./f-connection/common/f-path/f-connection-path.component";
+import * as i11 from "./f-connection/common/f-selection/f-connection-selection.component";
+import * as i12 from "./f-connection/f-connection/f-connection.component";
+import * as i13 from "./f-connection/f-connection-center/f-connection-center.directive";
+import * as i14 from "./f-connection/f-connection-for-create/f-connection-for-create.component";
+import * as i15 from "./f-connection/f-marker/f-marker.directive";
+import * as i16 from "./f-connectors/f-node-input/f-node-input.directive";
+import * as i17 from "./f-connectors/f-node-outlet/f-node-outlet.directive";
+import * as i18 from "./f-connectors/f-node-output/f-node-output.directive";
+import * as i19 from "./f-external-item/f-external-item.directive";
+import * as i20 from "./f-flow/f-flow.component";
+import * as i21 from "./f-line-alignment/f-line-alignment.component";
+import * as i22 from "./f-minimap/f-minimap.component";
+import * as i23 from "./f-minimap/f-minimap-canvas.directive";
+import * as i24 from "./f-minimap/f-minimap-view.directive";
+import * as i25 from "./f-minimap/f-minimap-flow.directive";
+import * as i26 from "./f-node/f-group.directive";
+import * as i27 from "./f-node/f-node.directive";
+import * as i28 from "./f-node/f-drag-handle/f-drag-handle.directive";
+import * as i29 from "./f-node/f-resize-handle/f-resize-handle.directive";
+import * as i30 from "./f-selection-area/f-selection-area.component";
+export class FFlowModule {
+}
+FFlowModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FFlowModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FFlowModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FFlowModule, declarations: [i1.FBackgroundComponent, i2.FRectPatternComponent, i3.FCirclePatternComponent, i4.FCanvasComponent, i5.FZoomDirective, i6.FConnectionTextComponent, i7.FConnectionTextPathDirective, i8.FConnectionDragHandleComponent, i9.FConnectionGradientComponent, i10.FConnectionPathComponent, i11.FConnectionSelectionComponent, i12.FConnectionComponent, i13.FConnectionCenterDirective, i14.FConnectionForCreateComponent, i15.FMarkerDirective, i16.FNodeInputDirective, i17.FNodeOutletDirective, i18.FNodeOutputDirective, i19.FExternalItemDirective, i20.FFlowComponent, i21.FLineAlignmentComponent, i22.FMinimapComponent, i23.FMinimapCanvasDirective, i24.FMinimapViewDirective, i25.FMinimapFlowDirective, i26.FGroupDirective, i27.FNodeDirective, i28.FDragHandleDirective, i29.FResizeHandleDirective, i30.FSelectionAreaComponent, FDraggableDirective], imports: [CommonModule], exports: [i1.FBackgroundComponent, i2.FRectPatternComponent, i3.FCirclePatternComponent, i4.FCanvasComponent, i5.FZoomDirective, i6.FConnectionTextComponent, i7.FConnectionTextPathDirective, i8.FConnectionDragHandleComponent, i9.FConnectionGradientComponent, i10.FConnectionPathComponent, i11.FConnectionSelectionComponent, i12.FConnectionComponent, i13.FConnectionCenterDirective, i14.FConnectionForCreateComponent, i15.FMarkerDirective, i16.FNodeInputDirective, i17.FNodeOutletDirective, i18.FNodeOutputDirective, i19.FExternalItemDirective, i20.FFlowComponent, i21.FLineAlignmentComponent, i22.FMinimapComponent, i23.FMinimapCanvasDirective, i24.FMinimapViewDirective, i25.FMinimapFlowDirective, i26.FGroupDirective, i27.FNodeDirective, i28.FDragHandleDirective, i29.FResizeHandleDirective, i30.FSelectionAreaComponent, FDraggableDirective] });
+FFlowModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FFlowModule, imports: [[
+            CommonModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FFlowModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...F_BACKGROUND_PROVIDERS,
+                        ...F_CANVAS_PROVIDERS,
+                        ...F_ZOOM_PROVIDERS,
+                        ...F_CONNECTION_PROVIDERS,
+                        ...F_CONNECTORS_PROVIDERS,
+                        ...F_EXTERNAL_ITEM_PROVIDERS,
+                        ...F_FLOW_PROVIDERS,
+                        ...F_LINE_ALIGNMENT_PROVIDERS,
+                        ...F_MINIMAP_PROVIDERS,
+                        ...F_NODE_PROVIDERS,
+                        ...F_SELECTION_AREA_PROVIDERS,
+                        FDraggableDirective,
+                    ],
+                    imports: [
+                        CommonModule,
+                    ],
+                    exports: [
+                        ...F_BACKGROUND_PROVIDERS,
+                        ...F_CANVAS_PROVIDERS,
+                        ...F_ZOOM_PROVIDERS,
+                        ...F_CONNECTION_PROVIDERS,
+                        ...F_CONNECTORS_PROVIDERS,
+                        ...F_EXTERNAL_ITEM_PROVIDERS,
+                        ...F_FLOW_PROVIDERS,
+                        ...F_LINE_ALIGNMENT_PROVIDERS,
+                        ...F_MINIMAP_PROVIDERS,
+                        ...F_NODE_PROVIDERS,
+                        ...F_SELECTION_AREA_PROVIDERS,
+                        FDraggableDirective,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-line-alignment/domain/line-element.js

@@ -0,0 +1,22 @@
+export class LineElement {
+    constructor(fBrowser, hostElement) {
+        this.hostElement = hostElement;
+        this.element = fBrowser.document.createElement('div');
+        this.hostElement.appendChild(this.element);
+        this.element.classList.add('f-line');
+    }
+    hide() {
+        this.element.style.display = 'none';
+    }
+    show() {
+        this.element.style.display = 'block';
+    }
+    draw(object) {
+        this.element.style.position = 'absolute';
+        Object.keys(object).forEach((key) => {
+            // @ts-ignore
+            this.element.style[key] = object[key] + 'px';
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-line-alignment/domain/line-service.js

@@ -0,0 +1,35 @@
+import { LineElement } from './line-element';
+export class LineService {
+    constructor(fBrowser, hostElement) {
+        this.hostElement = hostElement;
+        this.fHorizontalLine = new LineElement(fBrowser, this.hostElement);
+        this.fVerticalLine = new LineElement(fBrowser, this.hostElement);
+        this.fHorizontalLine.hide();
+        this.fVerticalLine.hide();
+    }
+    drawVerticalLine(x, size, transform) {
+        this.fVerticalLine.show();
+        this.fVerticalLine.draw({
+            left: x * transform.scale + transform.position.x + transform.scaledPosition.x,
+            top: 0,
+            width: 1,
+            height: size.height
+        });
+    }
+    drawHorizontalLine(y, size, transform) {
+        this.fHorizontalLine.show();
+        this.fHorizontalLine.draw({
+            left: 0,
+            top: y * transform.scale + transform.position.y + transform.scaledPosition.y,
+            width: size.width,
+            height: 1
+        });
+    }
+    hideVerticalLine() {
+        this.fVerticalLine.hide();
+    }
+    hideHorizontalLine() {
+        this.fHorizontalLine.hide();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-line-alignment/domain/nearest-coordinate.js

@@ -0,0 +1,101 @@
+/**
+ * A class to find the nearest coordinate.
+ */
+export class NearestCoordinateFinder {
+    /**
+     * Constructor to initialize the NearestCoordinateFinder.
+     * @param elements - The array of IRect elements.
+     * @param target - The target IRect element.
+     * @param alignThreshold - The threshold to align the elements.
+     */
+    constructor(elements, target, alignThreshold = 10) {
+        this.alignThreshold = alignThreshold;
+        this.elements = elements;
+        this.target = target;
+    }
+    /**
+     * Finds the nearest coordinate on a specified axis.
+     * @returns The nearest coordinate and its distance.
+     */
+    findNearestCoordinateByX() {
+        let nearest;
+        let minDistance;
+        for (const element of this.elements) {
+            const distanceLeftLeft = this.target.x - element.x;
+            const distanceLeftRight = this.target.x - (element.x + element.width);
+            const distanceCenterCenter = this.target.gravityCenter.x - element.gravityCenter.x;
+            const distanceRightLeft = (this.target.x + this.target.width) - element.x;
+            const distanceRightRight = (this.target.x + this.target.width) - (element.x + element.width);
+            if (Math.abs(distanceLeftLeft) <= this.alignThreshold ||
+                Math.abs(distanceLeftRight) <= this.alignThreshold ||
+                Math.abs(distanceCenterCenter) <= this.alignThreshold ||
+                Math.abs(distanceRightLeft) <= this.alignThreshold ||
+                Math.abs(distanceRightRight) <= this.alignThreshold) {
+                if (minDistance === undefined || Math.abs(distanceCenterCenter) < Math.abs(minDistance)) {
+                    minDistance = distanceCenterCenter;
+                    nearest = element.gravityCenter.x;
+                }
+                if (Math.abs(distanceLeftLeft) < Math.abs(minDistance)) {
+                    minDistance = distanceLeftLeft;
+                    nearest = element.x;
+                }
+                if (Math.abs(distanceRightRight) < Math.abs(minDistance)) {
+                    minDistance = distanceRightRight;
+                    nearest = element.x + element.width;
+                }
+                if (Math.abs(distanceLeftRight) < Math.abs(minDistance)) {
+                    minDistance = distanceLeftRight;
+                    nearest = element.x + element.width;
+                }
+                if (Math.abs(distanceRightLeft) < Math.abs(minDistance)) {
+                    minDistance = distanceRightLeft;
+                    nearest = element.x;
+                }
+            }
+        }
+        return { value: nearest, distance: minDistance };
+    }
+    /**
+     * Finds the nearest coordinate on a specified axis.
+     * @returns The nearest coordinate and its distance.
+     */
+    findNearestCoordinateByY() {
+        let nearest;
+        let minDistance;
+        for (const element of this.elements) {
+            const distanceTopTop = this.target.y - element.y;
+            const distanceTopBottom = this.target.y - (element.y + element.height);
+            const distanceCenterCenter = this.target.gravityCenter.y - element.gravityCenter.y;
+            const distanceBottomTop = (this.target.y + this.target.height) - element.y;
+            const distanceBottomBottom = (this.target.y + this.target.height) - (element.y + element.height);
+            if (Math.abs(distanceTopTop) <= this.alignThreshold ||
+                Math.abs(distanceTopBottom) <= this.alignThreshold ||
+                Math.abs(distanceCenterCenter) <= this.alignThreshold ||
+                Math.abs(distanceBottomTop) <= this.alignThreshold ||
+                Math.abs(distanceBottomBottom) <= this.alignThreshold) {
+                if (minDistance === undefined || Math.abs(distanceCenterCenter) < Math.abs(minDistance)) {
+                    minDistance = distanceCenterCenter;
+                    nearest = element.gravityCenter.y;
+                }
+                if (Math.abs(distanceTopTop) < Math.abs(minDistance)) {
+                    minDistance = distanceTopTop;
+                    nearest = element.y;
+                }
+                if (Math.abs(distanceBottomBottom) < Math.abs(minDistance)) {
+                    minDistance = distanceBottomBottom;
+                    nearest = element.y + element.height;
+                }
+                if (Math.abs(distanceTopBottom) < Math.abs(minDistance)) {
+                    minDistance = distanceTopBottom;
+                    nearest = element.y + element.height;
+                }
+                if (Math.abs(distanceBottomTop) < Math.abs(minDistance)) {
+                    minDistance = distanceBottomTop;
+                    nearest = element.y;
+                }
+            }
+        }
+        return { value: nearest, distance: minDistance };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nearest-coordinate.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-line-alignment/domain/nearest-coordinate.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRect } from '@foblex/2d';\nimport { INearestCoordinateResult } from './i-nearest-coordinate-result';\n\n/**\n * A class to find the nearest coordinate.\n */\nexport class NearestCoordinateFinder {\n\n\n  private elements: IRect[];\n  private target: IRect;\n\n  /**\n   * Constructor to initialize the NearestCoordinateFinder.\n   * @param elements - The array of IRect elements.\n   * @param target - The target IRect element.\n   * @param alignThreshold - The threshold to align the elements.\n   */\n  constructor(elements: IRect[], target: IRect, private alignThreshold: number = 10) {\n    this.elements = elements;\n    this.target = target;\n  }\n\n  /**\n   * Finds the nearest coordinate on a specified axis.\n   * @returns The nearest coordinate and its distance.\n   */\n  public findNearestCoordinateByX(): INearestCoordinateResult {\n    let nearest: number | undefined;\n    let minDistance: number | undefined;\n\n    for (const element of this.elements) {\n      const distanceLeftLeft = this.target.x - element.x;\n      const distanceLeftRight = this.target.x - (element.x + element.width);\n      const distanceCenterCenter = this.target.gravityCenter.x - element.gravityCenter.x;\n      const distanceRightLeft = (this.target.x + this.target.width) - element.x;\n      const distanceRightRight = (this.target.x + this.target.width) - (element.x + element.width);\n\n      if (\n          Math.abs(distanceLeftLeft) <= this.alignThreshold ||\n          Math.abs(distanceLeftRight) <= this.alignThreshold ||\n          Math.abs(distanceCenterCenter) <= this.alignThreshold ||\n          Math.abs(distanceRightLeft) <= this.alignThreshold ||\n          Math.abs(distanceRightRight) <= this.alignThreshold\n      ) {\n        if (minDistance === undefined || Math.abs(distanceCenterCenter) < Math.abs(minDistance)) {\n          minDistance = distanceCenterCenter;\n          nearest = element.gravityCenter.x;\n        }\n        if (Math.abs(distanceLeftLeft) < Math.abs(minDistance)) {\n          minDistance = distanceLeftLeft;\n          nearest = element.x;\n        }\n        if (Math.abs(distanceRightRight) < Math.abs(minDistance)) {\n          minDistance = distanceRightRight;\n          nearest = element.x + element.width;\n        }\n        if (Math.abs(distanceLeftRight) < Math.abs(minDistance)) {\n          minDistance = distanceLeftRight;\n          nearest = element.x + element.width;\n        }\n        if (Math.abs(distanceRightLeft) < Math.abs(minDistance)) {\n          minDistance = distanceRightLeft;\n          nearest = element.x;\n        }\n      }\n    }\n    return { value: nearest, distance: minDistance };\n  }\n\n\n  /**\n   * Finds the nearest coordinate on a specified axis.\n   * @returns The nearest coordinate and its distance.\n   */\n  public findNearestCoordinateByY(): INearestCoordinateResult {\n    let nearest: number | undefined;\n    let minDistance: number | undefined;\n\n    for (const element of this.elements) {\n      const distanceTopTop = this.target.y - element.y;\n      const distanceTopBottom = this.target.y - (element.y + element.height);\n      const distanceCenterCenter = this.target.gravityCenter.y - element.gravityCenter.y;\n      const distanceBottomTop = (this.target.y + this.target.height) - element.y;\n      const distanceBottomBottom = (this.target.y + this.target.height) - (element.y + element.height);\n\n      if (\n          Math.abs(distanceTopTop) <= this.alignThreshold ||\n          Math.abs(distanceTopBottom) <= this.alignThreshold ||\n          Math.abs(distanceCenterCenter) <= this.alignThreshold ||\n          Math.abs(distanceBottomTop) <= this.alignThreshold ||\n          Math.abs(distanceBottomBottom) <= this.alignThreshold\n      ) {\n        if (minDistance === undefined || Math.abs(distanceCenterCenter) < Math.abs(minDistance)) {\n          minDistance = distanceCenterCenter;\n          nearest = element.gravityCenter.y;\n        }\n        if (Math.abs(distanceTopTop) < Math.abs(minDistance)) {\n          minDistance = distanceTopTop;\n          nearest = element.y;\n        }\n        if (Math.abs(distanceBottomBottom) < Math.abs(minDistance)) {\n          minDistance = distanceBottomBottom;\n          nearest = element.y + element.height;\n        }\n        if (Math.abs(distanceTopBottom) < Math.abs(minDistance)) {\n          minDistance = distanceTopBottom;\n          nearest = element.y + element.height;\n        }\n        if (Math.abs(distanceBottomTop) < Math.abs(minDistance)) {\n          minDistance = distanceBottomTop;\n          nearest = element.y;\n        }\n      }\n    }\n\n    return { value: nearest, distance: minDistance };\n  }\n}\n\n"]}

package/esm2015/f-line-alignment/f-line-alignment-base.js

@@ -0,0 +1,11 @@
+import { Directive, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export const F_LINE_ALIGNMENT = new InjectionToken('F_LINE_ALIGNMENT');
+export class FLineAlignmentBase {
+}
+FLineAlignmentBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FLineAlignmentBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+FLineAlignmentBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FLineAlignmentBase, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FLineAlignmentBase, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1saW5lLWFsaWdubWVudC1iYXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWxpbmUtYWxpZ25tZW50L2YtbGluZS1hbGlnbm1lbnQtYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLMUQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxjQUFjLENBQXFCLGtCQUFrQixDQUFDLENBQUM7QUFHM0YsTUFBTSxPQUFnQixrQkFBa0I7O2dIQUFsQixrQkFBa0I7b0dBQWxCLGtCQUFrQjs0RkFBbEIsa0JBQWtCO2tCQUR2QyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSVBvaW50IH0gZnJvbSAnQGZvYmxleC8yZCc7XG5pbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJTGluZUFsaWdubWVudFJlc3VsdCB9IGZyb20gJy4vZG9tYWluJztcbmltcG9ydCB7IEZOb2RlQmFzZSB9IGZyb20gJy4uL2Ytbm9kZSc7XG5pbXBvcnQgeyBJSGFzSG9zdEVsZW1lbnQgfSBmcm9tICcuLi9pLWhhcy1ob3N0LWVsZW1lbnQnO1xuXG5leHBvcnQgY29uc3QgRl9MSU5FX0FMSUdOTUVOVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxGTGluZUFsaWdubWVudEJhc2U+KCdGX0xJTkVfQUxJR05NRU5UJyk7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZMaW5lQWxpZ25tZW50QmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQ7XG5cbiAgcHVibGljIGFic3RyYWN0IGluaXRpYWxpemUoYWxsTm9kZXM6IEZOb2RlQmFzZVtdLCBjdXJyZW50Tm9kZXM6IEZOb2RlQmFzZVtdKTogdm9pZDtcblxuICBwdWJsaWMgYWJzdHJhY3QgZmluZE5lYXJlc3RDb29yZGluYXRlKGRpZmZlcmVuY2U6IElQb2ludCk6IElMaW5lQWxpZ25tZW50UmVzdWx0O1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBoYW5kbGUoZGlmZmVyZW5jZTogSVBvaW50KTogdm9pZDtcblxuICBwdWJsaWMgYWJzdHJhY3QgY29tcGxldGUoKTogdm9pZDtcbn1cbiJdfQ==

package/esm2015/f-line-alignment/f-line-alignment.component.js

@@ -0,0 +1,99 @@
+import { Component, Input } from '@angular/core';
+import { RectExtensions, SizeExtensions } from '@foblex/2d';
+import { LineService, NearestCoordinateFinder } from './domain';
+import { F_LINE_ALIGNMENT, FLineAlignmentBase } from './f-line-alignment-base';
+import { GetElementRectInFlowRequest } from '../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-storage";
+import * as i2 from "../f-draggable";
+import * as i3 from "@foblex/mediator";
+import * as i4 from "@foblex/platform";
+export class FLineAlignmentComponent extends FLineAlignmentBase {
+    constructor(elementReference, fComponentsStore, fDraggableDataContext, fMediator, fBrowser) {
+        super();
+        this.elementReference = elementReference;
+        this.fComponentsStore = fComponentsStore;
+        this.fDraggableDataContext = fDraggableDataContext;
+        this.fMediator = fMediator;
+        this.fAlignThreshold = 10;
+        this.size = SizeExtensions.initialize();
+        this.draggedNodeRect = RectExtensions.initialize();
+        this.rects = [];
+        this.lineService = new LineService(fBrowser, this.hostElement);
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    get transform() {
+        return this.fComponentsStore.fCanvas.transform;
+    }
+    get flowHost() {
+        return this.fComponentsStore.fFlow.hostElement;
+    }
+    ngOnInit() {
+        this.fDraggableDataContext.fLineAlignment = this;
+    }
+    initialize(allNodes, currentNodes) {
+        this.size = this.flowHost.getBoundingClientRect();
+        this.rects = [];
+        const draggedNodeRects = currentNodes.map((x) => {
+            return this.fMediator.send(new GetElementRectInFlowRequest(x.hostElement));
+        });
+        this.draggedNodeRect = RectExtensions.union(draggedNodeRects) || RectExtensions.initialize();
+        const allNodesExcludeCurrents = allNodes.filter((x) => {
+            return !currentNodes.includes(x);
+        });
+        this.rects = allNodesExcludeCurrents.map((x) => {
+            return this.fMediator.send(new GetElementRectInFlowRequest(x.hostElement));
+        });
+    }
+    handle(difference) {
+        this.drawIntersectingLines(difference);
+    }
+    drawIntersectingLines(difference) {
+        const intersect = this.findNearestCoordinate(difference);
+        if (intersect.xResult.value !== undefined) {
+            this.lineService.drawVerticalLine(intersect.xResult.value, this.size, this.transform);
+        }
+        else {
+            this.lineService.hideVerticalLine();
+        }
+        if (intersect.yResult.value !== undefined) {
+            this.lineService.drawHorizontalLine(intersect.yResult.value, this.size, this.transform);
+        }
+        else {
+            this.lineService.hideHorizontalLine();
+        }
+    }
+    findNearestCoordinate(difference) {
+        const rect = RectExtensions.addPoint(this.draggedNodeRect, difference);
+        const finder = new NearestCoordinateFinder(this.rects, rect, this.fAlignThreshold);
+        return { xResult: finder.findNearestCoordinateByX(), yResult: finder.findNearestCoordinateByY() };
+    }
+    complete() {
+        this.lineService.hideVerticalLine();
+        this.lineService.hideHorizontalLine();
+    }
+}
+FLineAlignmentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FLineAlignmentComponent, deps: [{ token: i0.ElementRef }, { token: i1.FComponentsStore }, { token: i2.FDraggableDataContext }, { token: i3.FMediator }, { token: i4.BrowserService }], target: i0.ɵɵFactoryTarget.Component });
+FLineAlignmentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FLineAlignmentComponent, selector: "f-line-alignment", inputs: { fAlignThreshold: "fAlignThreshold" }, host: { classAttribute: "f-line-alignment f-component" }, providers: [
+        { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }
+    ], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0, template: "", isInline: true, styles: [":host{display:block;position:absolute;left:0;top:0;width:100%;height:100%;overflow:hidden;pointer-events:none;-webkit-user-select:none;user-select:none}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FLineAlignmentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "f-line-alignment",
+                    template: "",
+                    styleUrls: ["./f-line-alignment.component.scss"],
+                    exportAs: "fComponent",
+                    host: {
+                        'class': 'f-line-alignment f-component'
+                    },
+                    providers: [
+                        { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FComponentsStore }, { type: i2.FDraggableDataContext }, { type: i3.FMediator }, { type: i4.BrowserService }]; }, propDecorators: { fAlignThreshold: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-line-alignment.component.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-line-alignment/f-line-alignment.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, Input, OnInit } from '@angular/core';\nimport { IPoint, IRect, ISize, ITransformModel, RectExtensions, SizeExtensions } from '@foblex/2d';\nimport { ILineAlignmentResult, LineService, NearestCoordinateFinder } from './domain';\nimport { F_LINE_ALIGNMENT, FLineAlignmentBase } from './f-line-alignment-base';\nimport { FComponentsStore } from '../f-storage';\nimport { FDraggableDataContext } from '../f-draggable';\nimport { FNodeBase } from '../f-node';\nimport { GetElementRectInFlowRequest } from '../domain';\nimport { FMediator } from '@foblex/mediator';\nimport { BrowserService } from '@foblex/platform';\n\n@Component({\n  selector: \"f-line-alignment\",\n  template: \"\",\n  styleUrls: [ \"./f-line-alignment.component.scss\" ],\n  exportAs: \"fComponent\",\n  host: {\n    'class': 'f-line-alignment f-component'\n  },\n  providers: [\n    { provide: F_LINE_ALIGNMENT, useExisting: FLineAlignmentComponent }\n  ],\n})\nexport class FLineAlignmentComponent extends FLineAlignmentBase implements OnInit {\n\n  @Input()\n  public fAlignThreshold: number = 10;\n\n  public override get hostElement(): HTMLElement {\n    return this.elementReference.nativeElement;\n  }\n\n  private lineService: LineService;\n\n  private size: ISize = SizeExtensions.initialize();\n\n  private draggedNodeRect: IRect = RectExtensions.initialize();\n\n  private rects: IRect[] = [];\n\n  private get transform(): ITransformModel {\n    return this.fComponentsStore.fCanvas!.transform;\n  }\n\n  private get flowHost(): HTMLElement {\n    return this.fComponentsStore.fFlow!.hostElement;\n  }\n\n  constructor(\n    private elementReference: ElementRef<HTMLElement>,\n    private fComponentsStore: FComponentsStore,\n    private fDraggableDataContext: FDraggableDataContext,\n    private fMediator: FMediator,\n    fBrowser: BrowserService\n  ) {\n    super();\n    this.lineService = new LineService(fBrowser, this.hostElement);\n  }\n\n  public ngOnInit(): void {\n    this.fDraggableDataContext.fLineAlignment = this;\n  }\n\n  public override initialize(allNodes: FNodeBase[], currentNodes: FNodeBase[]): void {\n    this.size = this.flowHost.getBoundingClientRect();\n    this.rects = [];\n    const draggedNodeRects = currentNodes.map((x) => {\n      return this.fMediator.send<IRect>(new GetElementRectInFlowRequest(x.hostElement));\n    });\n    this.draggedNodeRect = RectExtensions.union(draggedNodeRects) || RectExtensions.initialize();\n\n    const allNodesExcludeCurrents = allNodes.filter((x) => {\n      return !currentNodes.includes(x);\n    });\n\n    this.rects = allNodesExcludeCurrents.map((x) => {\n      return this.fMediator.send<IRect>(new GetElementRectInFlowRequest(x.hostElement));\n    });\n  }\n\n  public override handle(difference: IPoint): void {\n    this.drawIntersectingLines(difference);\n  }\n\n  private drawIntersectingLines(difference: IPoint): void {\n    const intersect = this.findNearestCoordinate(difference);\n    if (intersect.xResult.value !== undefined) {\n      this.lineService.drawVerticalLine(intersect.xResult.value, this.size, this.transform);\n    } else {\n      this.lineService.hideVerticalLine();\n    }\n    if (intersect.yResult.value !== undefined) {\n      this.lineService.drawHorizontalLine(intersect.yResult.value, this.size, this.transform);\n    } else {\n      this.lineService.hideHorizontalLine();\n    }\n  }\n\n  public findNearestCoordinate(difference: IPoint): ILineAlignmentResult {\n    const rect = RectExtensions.addPoint(this.draggedNodeRect, difference);\n    const finder = new NearestCoordinateFinder(this.rects, rect, this.fAlignThreshold);\n\n    return { xResult: finder.findNearestCoordinateByX(), yResult: finder.findNearestCoordinateByY() };\n  }\n\n  public override complete(): void {\n    this.lineService.hideVerticalLine();\n    this.lineService.hideHorizontalLine();\n  }\n}\n"]}