@foblex/flow 12.6.2 → 12.6.4

package/esm2015/f-backgroud/f-rect-pattern/f-rect-pattern.component.js

@@ -0,0 +1,122 @@
+import { ChangeDetectionStrategy, Component, Input } from "@angular/core";
+import { PointExtensions, SizeExtensions, TransformModelExtensions } from '@foblex/2d';
+import { F_BACKGROUND_PATTERN } from '../domain';
+import { Subject, Subscription } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { createSVGElement } from '../../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "@foblex/platform";
+let uniqueId = 0;
+export class FRectPatternComponent {
+    constructor(elementReference, fBrowser) {
+        this.elementReference = elementReference;
+        this.fBrowser = fBrowser;
+        this._subscription$ = new Subscription();
+        this._stateChanges = new Subject();
+        this.id = `f-pattern-${uniqueId++}`;
+        this._vColor = 'rgba(0,0,0,0.1)';
+        this._hColor = 'rgba(0,0,0,0.1)';
+        this._vSize = 20;
+        this._hSize = 20;
+        this._transform = TransformModelExtensions.default();
+        this._position = PointExtensions.initialize();
+        this._size = SizeExtensions.initialize(this._hSize, this._vSize);
+        this.createPattern();
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    set vColor(value) {
+        this._vColor = value;
+        this._stateChanges.next();
+    }
+    set hColor(value) {
+        this._vColor = value;
+        this._stateChanges.next();
+    }
+    set vSize(value) {
+        this._vSize = value;
+        this._stateChanges.next();
+    }
+    set hSize(value) {
+        this._hSize = value;
+        this._stateChanges.next();
+    }
+    createPattern() {
+        this._pattern = createSVGElement('pattern', this.fBrowser);
+        this._pattern.setAttribute('patternUnits', 'userSpaceOnUse');
+        this.hostElement.appendChild(this._pattern);
+        this._vLine = createSVGElement('line', this.fBrowser);
+        this._pattern.appendChild(this._vLine);
+        this._hLine = createSVGElement('line', this.fBrowser);
+        this._pattern.appendChild(this._hLine);
+    }
+    ngOnInit() {
+        this._subscription$.add(this.subscribeToStateChanges());
+    }
+    subscribeToStateChanges() {
+        return this._stateChanges.pipe(startWith(null)).subscribe(() => {
+            this.redraw();
+        });
+    }
+    calculatePattern() {
+        this._position.x = this._transform.position.x + this._transform.scaledPosition.x;
+        this._position.y = this._transform.position.y + this._transform.scaledPosition.y;
+        this._size = SizeExtensions.initialize(this._hSize * this._transform.scale, this._vSize * this._transform.scale);
+    }
+    redraw() {
+        this.calculatePattern();
+        this.redrawPattern();
+        this.redrawLine(this._vLine, this._vColor, this._size.width, 0, this._size.width, this._size.height);
+        this.redrawLine(this._hLine, this._hColor, 0, this._size.height, this._size.width, this._size.height);
+    }
+    redrawPattern() {
+        this._pattern.setAttribute('x', `${this._position.x}`);
+        this._pattern.setAttribute('y', `${this._position.y}`);
+        this._pattern.setAttribute('width', `${this._size.width}`);
+        this._pattern.setAttribute('height', `${this._size.height}`);
+    }
+    redrawLine(line, color, x1, y1, x2, y2) {
+        line.setAttribute('stroke', `${color}`);
+        line.setAttribute('x1', `${x1}`);
+        line.setAttribute('x2', `${x2}`);
+        line.setAttribute('y1', `${y1}`);
+        line.setAttribute('y2', `${y2}`);
+    }
+    setTransform(transform) {
+        this._transform = transform;
+        this._stateChanges.next();
+    }
+    ngOnDestroy() {
+        this._subscription$.unsubscribe();
+    }
+}
+FRectPatternComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FRectPatternComponent, deps: [{ token: i0.ElementRef }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Component });
+FRectPatternComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FRectPatternComponent, selector: "f-rect-pattern", inputs: { id: "id", vColor: "vColor", hColor: "hColor", vSize: "vSize", hSize: "hSize" }, host: { properties: { "attr.id": "id" } }, providers: [
+        { provide: F_BACKGROUND_PATTERN, useExisting: FRectPatternComponent }
+    ], ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FRectPatternComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "f-rect-pattern",
+                    template: ``,
+                    host: {
+                        '[attr.id]': 'id'
+                    },
+                    providers: [
+                        { provide: F_BACKGROUND_PATTERN, useExisting: FRectPatternComponent }
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.BrowserService }]; }, propDecorators: { id: [{
+                type: Input
+            }], vColor: [{
+                type: Input
+            }], hColor: [{
+                type: Input
+            }], vSize: [{
+                type: Input
+            }], hSize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-rect-pattern.component.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-backgroud/f-rect-pattern/f-rect-pattern.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef, Input, OnDestroy,\n  OnInit\n} from \"@angular/core\";\nimport {\n  IPoint, ISize, ITransformModel,\n  PointExtensions, SizeExtensions, TransformModelExtensions\n} from '@foblex/2d';\nimport { F_BACKGROUND_PATTERN, IFBackgroundPattern } from '../domain';\nimport { Subject, Subscription } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { createSVGElement } from '../../domain';\nimport { BrowserService } from '@foblex/platform';\n\nlet uniqueId: number = 0;\n\n@Component({\n  selector: \"f-rect-pattern\",\n  template: ``,\n  host: {\n    '[attr.id]': 'id'\n  },\n  providers: [\n    { provide: F_BACKGROUND_PATTERN, useExisting: FRectPatternComponent }\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FRectPatternComponent implements OnInit, OnDestroy, IFBackgroundPattern {\n\n  private _subscription$: Subscription = new Subscription();\n\n  private _stateChanges: Subject<void> = new Subject<void>();\n\n  public get hostElement(): HTMLElement {\n    return this.elementReference.nativeElement;\n  }\n\n  @Input()\n  public id: string = `f-pattern-${ uniqueId++ }`;\n\n  private _vColor: string = 'rgba(0,0,0,0.1)';\n\n  @Input()\n  public set vColor(value: string) {\n    this._vColor = value;\n    this._stateChanges.next();\n  }\n\n  private _hColor: string = 'rgba(0,0,0,0.1)';\n\n  @Input()\n  public set hColor(value: string) {\n    this._vColor = value;\n    this._stateChanges.next();\n  }\n\n  private _vSize: number = 20;\n\n  @Input()\n  public set vSize(value: number) {\n    this._vSize = value;\n    this._stateChanges.next();\n  }\n\n  private _hSize: number = 20;\n\n  @Input()\n  public set hSize(value: number) {\n    this._hSize = value;\n    this._stateChanges.next();\n  }\n\n  private _transform: ITransformModel = TransformModelExtensions.default();\n\n  private _position: IPoint = PointExtensions.initialize();\n\n  private _size: ISize = SizeExtensions.initialize(this._hSize, this._vSize);\n\n  private _pattern!: SVGPatternElement;\n  private _vLine!: SVGLineElement;\n  private _hLine!: SVGLineElement;\n\n  constructor(\n    private elementReference: ElementRef<HTMLElement>,\n    private fBrowser: BrowserService\n  ) {\n    this.createPattern();\n  }\n\n  private createPattern(): void {\n    this._pattern = createSVGElement('pattern', this.fBrowser);\n    this._pattern.setAttribute('patternUnits', 'userSpaceOnUse');\n    this.hostElement.appendChild(this._pattern);\n\n    this._vLine = createSVGElement('line', this.fBrowser);\n    this._pattern.appendChild(this._vLine);\n\n    this._hLine = createSVGElement('line', this.fBrowser);\n    this._pattern.appendChild(this._hLine);\n  }\n\n  public ngOnInit(): void {\n    this._subscription$.add(this.subscribeToStateChanges());\n  }\n\n  private subscribeToStateChanges(): Subscription {\n    return this._stateChanges.pipe(startWith(null)).subscribe(() => {\n      this.redraw();\n    });\n  }\n\n  private calculatePattern(): void {\n    this._position.x = this._transform.position.x + this._transform.scaledPosition.x;\n    this._position.y = this._transform.position.y + this._transform.scaledPosition.y;\n    this._size = SizeExtensions.initialize(this._hSize * this._transform.scale, this._vSize * this._transform.scale);\n  }\n\n  private redraw(): void {\n    this.calculatePattern();\n    this.redrawPattern();\n\n    this.redrawLine(this._vLine, this._vColor, this._size.width, 0, this._size.width, this._size.height);\n    this.redrawLine(this._hLine, this._hColor, 0, this._size.height, this._size.width, this._size.height);\n  }\n\n  private redrawPattern(): void {\n    this._pattern.setAttribute('x', `${ this._position.x }`);\n    this._pattern.setAttribute('y', `${ this._position.y }`);\n    this._pattern.setAttribute('width', `${ this._size.width }`);\n    this._pattern.setAttribute('height', `${ this._size.height }`);\n  }\n\n  private redrawLine(line: SVGLineElement, color: string, x1: number, y1: number, x2: number, y2: number): void {\n    line.setAttribute('stroke', `${ color }`);\n    line.setAttribute('x1', `${ x1 }`);\n    line.setAttribute('x2', `${ x2 }`);\n    line.setAttribute('y1', `${ y1 }`);\n    line.setAttribute('y2', `${ y2 }`);\n  }\n\n  public setTransform(transform: ITransformModel): void {\n    this._transform = transform;\n    this._stateChanges.next();\n  }\n\n  public ngOnDestroy(): void {\n    this._subscription$.unsubscribe();\n  }\n}\n"]}

package/esm2015/f-canvas/domain/f-canvas-change.event.js

@@ -0,0 +1,7 @@
+export class FCanvasChangeEvent {
+    constructor(position, scale) {
+        this.position = position;
+        this.scale = scale;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1jYW52YXMtY2hhbmdlLmV2ZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNhbnZhcy9kb21haW4vZi1jYW52YXMtY2hhbmdlLmV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxrQkFBa0I7SUFDM0IsWUFDb0IsUUFBZ0IsRUFDaEIsS0FBYTtRQURiLGFBQVEsR0FBUixRQUFRLENBQVE7UUFDaEIsVUFBSyxHQUFMLEtBQUssQ0FBUTtJQUVqQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4LzJkJztcblxuZXhwb3J0IGNsYXNzIEZDYW52YXNDaGFuZ2VFdmVudCB7XG4gICAgY29uc3RydWN0b3IoXG4gICAgICAgIHB1YmxpYyByZWFkb25seSBwb3NpdGlvbjogSVBvaW50LFxuICAgICAgICBwdWJsaWMgcmVhZG9ubHkgc2NhbGU6IG51bWJlcixcbiAgICApIHtcbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,28 @@
+import { mixinChangePosition, mixinChangeZoom, mixinFitToParent, mixinOneToOneCentering } from '../mixins';
+import { PointExtensions, TransformModelExtensions } from '@foblex/2d';
+import { Directive, InjectionToken } from '@angular/core';
+import { FCanvasChangeEvent } from './domain';
+import * as i0 from "@angular/core";
+export const F_CANVAS = new InjectionToken('F_CANVAS');
+const MIXIN_BASE = mixinChangePosition(mixinFitToParent(mixinOneToOneCentering(mixinChangeZoom(class {
+    constructor(transform) {
+        this.transform = transform;
+    }
+}))));
+export class FCanvasBase extends MIXIN_BASE {
+    constructor() {
+        super(TransformModelExtensions.default());
+    }
+    completeDrag() {
+        this.fCanvasChange.emit(new FCanvasChangeEvent(this.getCanvasPosition(), this.transform.scale));
+    }
+    getCanvasPosition() {
+        return PointExtensions.sum(this.transform.position, this.transform.scaledPosition);
+    }
+}
+FCanvasBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FCanvasBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+FCanvasBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FCanvasBase, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FCanvasBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,120 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, } from "@angular/core";
+import { FCanvasBase, F_CANVAS } from './f-canvas-base';
+import { Point, PointExtensions, RectExtensions, TransformModelExtensions } from '@foblex/2d';
+import { CenterGroupOrNodeRequest, EmitTransformChangesRequest, F_CANVAS_ANIMATION_DURATION, GetNodesRectRequest } from '../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "@foblex/mediator";
+import * as i2 from "../f-storage";
+export class FCanvasComponent extends FCanvasBase {
+    constructor(elementReference, fMediator, fComponentsStore) {
+        super();
+        this.elementReference = elementReference;
+        this.fMediator = fMediator;
+        this.fComponentsStore = fComponentsStore;
+        this.fCanvasChange = new EventEmitter();
+    }
+    set position(value) {
+        if (!value) {
+            return;
+        }
+        const position = PointExtensions.sum(this.transform.position, this.transform.scaledPosition);
+        if (!PointExtensions.isEqual(position, value)) {
+            this.transform.position = value;
+            this.transform.scaledPosition = PointExtensions.initialize();
+            this.redraw();
+        }
+    }
+    set scale(value) {
+        if (!value) {
+            return;
+        }
+        this.transform.scale = value;
+        this.redraw();
+    }
+    get fNodes() {
+        return this.fComponentsStore.fNodes;
+    }
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    ngOnInit() {
+        this.fComponentsStore.fCanvas = this;
+    }
+    redraw() {
+        var _a;
+        (_a = this.fComponentsStore.fBackground) === null || _a === void 0 ? void 0 : _a.setTransform(this.transform);
+        this.hostElement.setAttribute("style", `transform: ${TransformModelExtensions.toString(this.transform)}`);
+        this.fMediator.send(new EmitTransformChangesRequest());
+    }
+    redrawWithAnimation() {
+        var _a;
+        (_a = this.fComponentsStore.fBackground) === null || _a === void 0 ? void 0 : _a.setTransform(this.transform);
+        this.hostElement.setAttribute("style", `transition: transform ${F_CANVAS_ANIMATION_DURATION}ms ease-in-out; transform: ${TransformModelExtensions.toString(this.transform)}`);
+        setTimeout(() => {
+            this.redraw();
+        }, F_CANVAS_ANIMATION_DURATION);
+    }
+    centerGroupOrNode(id, animated = true) {
+        this.fMediator.send(new CenterGroupOrNodeRequest(id, animated));
+    }
+    fitToScreen(toCenter = PointExtensions.initialize(), animated = true) {
+        const fNodesRect = this.fMediator.send(new GetNodesRectRequest()) || RectExtensions.initialize();
+        if (fNodesRect.width === 0 || fNodesRect.height === 0) {
+            return;
+        }
+        this.fitToParent(fNodesRect, RectExtensions.fromElement(this.fComponentsStore.fFlow.hostElement), this.fNodes.map((x) => {
+            return Point.fromPoint(x.position);
+        }), toCenter);
+        animated ? this.redrawWithAnimation() : this.redraw();
+        this.completeDrag();
+        setTimeout(() => {
+            this.fComponentsStore.componentDataChanged();
+        }, F_CANVAS_ANIMATION_DURATION);
+    }
+    oneToOne() {
+        const fNodesRect = this.fMediator.send(new GetNodesRectRequest()) || RectExtensions.initialize();
+        if (fNodesRect.width === 0 || fNodesRect.height === 0) {
+            return;
+        }
+        this.oneToOneCentering(fNodesRect, RectExtensions.fromElement(this.fComponentsStore.fFlow.hostElement), this.fNodes.map((x) => {
+            return Point.fromPoint(x.position);
+        }));
+        this.redrawWithAnimation();
+        this.completeDrag();
+        setTimeout(() => {
+            this.fComponentsStore.componentDataChanged();
+        }, F_CANVAS_ANIMATION_DURATION);
+    }
+}
+FCanvasComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FCanvasComponent, deps: [{ token: i0.ElementRef }, { token: i1.FMediator }, { token: i2.FComponentsStore }], target: i0.ɵɵFactoryTarget.Component });
+FCanvasComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: FCanvasComponent, selector: "f-canvas", inputs: { position: "position", scale: "scale" }, outputs: { fCanvasChange: "fCanvasChange" }, host: { classAttribute: "f-component f-canvas" }, providers: [{ provide: F_CANVAS, useExisting: FCanvasComponent }], viewQueries: [{ propertyName: "fGroupsContainer", first: true, predicate: ["fGroupsContainer"], descendants: true, static: true }, { propertyName: "fNodesContainer", first: true, predicate: ["fNodesContainer"], descendants: true, static: true }, { propertyName: "fConnectionsContainer", first: true, predicate: ["fConnectionsContainer"], descendants: true, static: true }], exportAs: ["fComponent"], usesInheritance: true, ngImport: i0, template: "<ng-container>\n  <div #fGroupsContainer>\n    <ng-content select=\"[fGroup]\"></ng-content>\n  </div>\n  <div #fConnectionsContainer>\n    <ng-content select=\"f-snap-connection\"></ng-content>\n    <ng-content select=\"f-connection\"></ng-content>\n    <ng-content select=\"f-connection-for-create\"></ng-content>\n  </div>\n\n  <div #fNodesContainer>\n    <ng-content select=\"[fNode]\"></ng-content>\n  </div>\n</ng-container>\n", styles: [":host{position:absolute;overflow:visible;width:100%;height:100%;left:0;top:0;transform-origin:0 0;pointer-events:none}:host.f-scaled-animate{transition:transform .09s}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FCanvasComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'f-canvas',
+                    templateUrl: './f-canvas.component.html',
+                    styleUrls: ['./f-canvas.component.scss'],
+                    exportAs: 'fComponent',
+                    host: {
+                        'class': 'f-component f-canvas',
+                    },
+                    providers: [{ provide: F_CANVAS, useExisting: FCanvasComponent }],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FMediator }, { type: i2.FComponentsStore }]; }, propDecorators: { fCanvasChange: [{
+                type: Output
+            }], position: [{
+                type: Input
+            }], scale: [{
+                type: Input
+            }], fGroupsContainer: [{
+                type: ViewChild,
+                args: ['fGroupsContainer', { static: true }]
+            }], fNodesContainer: [{
+                type: ViewChild,
+                args: ['fNodesContainer', { static: true }]
+            }], fConnectionsContainer: [{
+                type: ViewChild,
+                args: ['fConnectionsContainer', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-canvas.component.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-canvas/f-canvas.component.ts","../../../../projects/f-flow/src/f-canvas/f-canvas.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component, ElementRef, EventEmitter, Input, OnInit, Output, ViewChild,\n} from \"@angular/core\";\nimport {\n  FCanvasBase, F_CANVAS\n} from './f-canvas-base';\nimport { IPoint, IRect, Point, PointExtensions, RectExtensions, TransformModelExtensions } from '@foblex/2d';\nimport { FCanvasChangeEvent } from './domain';\nimport { FComponentsStore } from '../f-storage';\nimport { FNodeBase } from '../f-node';\nimport { FMediator } from '@foblex/mediator';\nimport {\n  CenterGroupOrNodeRequest,\n  EmitTransformChangesRequest,\n  F_CANVAS_ANIMATION_DURATION,\n  GetNodesRectRequest\n} from '../domain';\n\n@Component({\n  selector: 'f-canvas',\n  templateUrl: './f-canvas.component.html',\n  styleUrls: [ './f-canvas.component.scss' ],\n  exportAs: 'fComponent',\n  host: {\n    'class': 'f-component f-canvas',\n  },\n  providers: [ { provide: F_CANVAS, useExisting: FCanvasComponent } ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class FCanvasComponent extends FCanvasBase implements OnInit {\n\n  @Output()\n  public override fCanvasChange: EventEmitter<FCanvasChangeEvent> = new EventEmitter<FCanvasChangeEvent>();\n\n  @Input()\n  public set position(value: IPoint | undefined) {\n    if (!value) {\n      return;\n    }\n    const position = PointExtensions.sum(this.transform.position, this.transform.scaledPosition);\n    if (!PointExtensions.isEqual(position, value)) {\n      this.transform.position = value;\n      this.transform.scaledPosition = PointExtensions.initialize();\n      this.redraw();\n    }\n  }\n\n  @Input()\n  public set scale(value: number | undefined) {\n    if (!value) {\n      return;\n    }\n    this.transform.scale = value;\n    this.redraw();\n  }\n\n  public override get fNodes(): FNodeBase[] {\n    return this.fComponentsStore.fNodes;\n  }\n\n  public override get hostElement(): HTMLElement {\n    return this.elementReference.nativeElement;\n  }\n\n  @ViewChild('fGroupsContainer', { static: true })\n  public override fGroupsContainer!: ElementRef<HTMLElement>;\n\n  @ViewChild('fNodesContainer', { static: true })\n  public override fNodesContainer!: ElementRef<HTMLElement>;\n\n  @ViewChild('fConnectionsContainer', { static: true })\n  public override fConnectionsContainer!: ElementRef<HTMLElement>;\n\n  constructor(\n    private elementReference: ElementRef<HTMLElement>,\n    private fMediator: FMediator,\n    private fComponentsStore: FComponentsStore,\n  ) {\n    super();\n  }\n\n  public ngOnInit() {\n    this.fComponentsStore.fCanvas = this;\n  }\n\n  public override redraw(): void {\n    this.fComponentsStore.fBackground?.setTransform(this.transform);\n    this.hostElement.setAttribute(\"style\", `transform: ${ TransformModelExtensions.toString(this.transform) }`);\n    this.fMediator.send(new EmitTransformChangesRequest());\n  }\n\n  public override redrawWithAnimation(): void {\n    this.fComponentsStore.fBackground?.setTransform(this.transform);\n    this.hostElement.setAttribute(\"style\", `transition: transform ${ F_CANVAS_ANIMATION_DURATION }ms ease-in-out; transform: ${ TransformModelExtensions.toString(this.transform) }`);\n    setTimeout(() => {\n      this.redraw();\n    }, F_CANVAS_ANIMATION_DURATION);\n  }\n\n  public centerGroupOrNode(id: string, animated: boolean = true): void {\n    this.fMediator.send(new CenterGroupOrNodeRequest(id, animated));\n  }\n\n  public fitToScreen(toCenter: IPoint = PointExtensions.initialize(), animated: boolean = true): void {\n    const fNodesRect = this.fMediator.send<IRect | null>(new GetNodesRectRequest()) || RectExtensions.initialize();\n    if (fNodesRect.width === 0 || fNodesRect.height === 0) {\n      return;\n    }\n\n    this.fitToParent(\n      fNodesRect,\n      RectExtensions.fromElement(this.fComponentsStore.fFlow!.hostElement),\n      this.fNodes.map((x) => {\n        return Point.fromPoint(x.position)\n      }),\n      toCenter\n    );\n    animated ? this.redrawWithAnimation() : this.redraw();\n    this.completeDrag();\n    setTimeout(() => {\n      this.fComponentsStore.componentDataChanged();\n    }, F_CANVAS_ANIMATION_DURATION);\n  }\n\n  public oneToOne(): void {\n    const fNodesRect = this.fMediator.send<IRect | null>(new GetNodesRectRequest()) || RectExtensions.initialize();\n    if (fNodesRect.width === 0 || fNodesRect.height === 0) {\n      return;\n    }\n    this.oneToOneCentering(\n      fNodesRect,\n      RectExtensions.fromElement(this.fComponentsStore.fFlow!.hostElement),\n      this.fNodes.map((x) => {\n        return Point.fromPoint(x.position)\n      })\n    );\n    this.redrawWithAnimation();\n    this.completeDrag();\n    setTimeout(() => {\n      this.fComponentsStore.componentDataChanged();\n    }, F_CANVAS_ANIMATION_DURATION);\n  }\n}\n","<ng-container>\n  <div #fGroupsContainer>\n    <ng-content select=\"[fGroup]\"></ng-content>\n  </div>\n  <div #fConnectionsContainer>\n    <ng-content select=\"f-snap-connection\"></ng-content>\n    <ng-content select=\"f-connection\"></ng-content>\n    <ng-content select=\"f-connection-for-create\"></ng-content>\n  </div>\n\n  <div #fNodesContainer>\n    <ng-content select=\"[fNode]\"></ng-content>\n  </div>\n</ng-container>\n"]}

package/esm2015/f-connection/common/domain/calculate-center-between-points/calculate-center-between-points-request.js

@@ -0,0 +1,7 @@
+export class CalculateCenterBetweenPointsRequest {
+    constructor(source, target) {
+        this.source = source;
+        this.target = target;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsY3VsYXRlLWNlbnRlci1iZXR3ZWVuLXBvaW50cy1yZXF1ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWNvbm5lY3Rpb24vY29tbW9uL2RvbWFpbi9jYWxjdWxhdGUtY2VudGVyLWJldHdlZW4tcG9pbnRzL2NhbGN1bGF0ZS1jZW50ZXItYmV0d2Vlbi1wb2ludHMtcmVxdWVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sbUNBQW1DO0lBRTVDLFlBQ1csTUFBYyxFQUNkLE1BQWM7UUFEZCxXQUFNLEdBQU4sTUFBTSxDQUFRO1FBQ2QsV0FBTSxHQUFOLE1BQU0sQ0FBUTtJQUV6QixDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnQgfSBmcm9tICdAZm9ibGV4LzJkJztcblxuZXhwb3J0IGNsYXNzIENhbGN1bGF0ZUNlbnRlckJldHdlZW5Qb2ludHNSZXF1ZXN0IHtcblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwdWJsaWMgc291cmNlOiBJUG9pbnQsXG4gICAgICAgIHB1YmxpYyB0YXJnZXQ6IElQb2ludCxcbiAgICApIHtcbiAgICB9XG59XG4iXX0=

package/esm2015/f-connection/common/domain/calculate-center-between-points/calculate-center-between-points.handler.js

@@ -0,0 +1,12 @@
+import { PointExtensions } from '@foblex/2d';
+export class CalculateCenterBetweenPointsHandler {
+    handle(request) {
+        const { source, target } = request;
+        const offsetX = Math.abs(target.x - source.x) / 2;
+        const centerX = (target.x < source.x) ? target.x + offsetX : target.x - offsetX;
+        const offsetY = Math.abs(target.y - source.y) / 2;
+        const centerY = (target.y < source.y) ? target.y + offsetY : target.y - offsetY;
+        return PointExtensions.initialize(centerX, centerY);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-connection/common/domain/calculate-connection-center/calculate-connection-center-request.js

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

package/esm2015/f-connection/common/domain/calculate-connection-center/calculate-connection-center.handler.js

@@ -0,0 +1,35 @@
+export class CalculateConnectionCenterHandler {
+    handle(request) {
+        const { points } = request;
+        let totalDistance = 0;
+        let distances = [];
+        for (let i = 0; i < points.length - 1; i++) {
+            const distance = this.calculateDistance(points[i], points[i + 1]);
+            distances.push(distance);
+            totalDistance += distance;
+        }
+        let accumulatedDistance = 0;
+        let centerIndex = 0;
+        const halfTotalDistance = totalDistance / 2;
+        for (let i = 0; i < distances.length; i++) {
+            accumulatedDistance += distances[i];
+            if (accumulatedDistance >= halfTotalDistance) {
+                centerIndex = i;
+                break;
+            }
+        }
+        const remainingDistanceToCenter = halfTotalDistance - (accumulatedDistance - distances[centerIndex]);
+        return this.findPointAtDistance(points[centerIndex], points[centerIndex + 1], remainingDistanceToCenter);
+    }
+    calculateDistance(pointA, pointB) {
+        return Math.sqrt(Math.pow(pointB.x - pointA.x, 2) + Math.pow(pointB.y - pointA.y, 2));
+    }
+    findPointAtDistance(startPoint, endPoint, distance) {
+        const totalDistance = this.calculateDistance(startPoint, endPoint);
+        const ratio = distance / totalDistance;
+        const x = (1 - ratio) * startPoint.x + ratio * endPoint.x;
+        const y = (1 - ratio) * startPoint.y + ratio * endPoint.y;
+        return { x, y };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/f-connection/common/domain/f-bezier.path-builder.js

@@ -0,0 +1,37 @@
+import { EFConnectableSide } from '../../../f-connectors';
+import { CalculateConnectionCenterHandler, CalculateConnectionCenterRequest } from './calculate-connection-center';
+export class FBezierPathBuilder {
+    static getConnectorOffset(distance, offset) {
+        if (distance >= offset) {
+            return distance;
+        }
+        return offset * Math.sqrt(offset - distance);
+    }
+    static getAnglePoint(side, source, target, offset) {
+        let result = { x: source.x, y: source.y };
+        switch (side) {
+            case EFConnectableSide.LEFT:
+                result.x -= FBezierPathBuilder.getConnectorOffset(source.x - target.x, offset);
+                break;
+            case EFConnectableSide.RIGHT:
+                result.x += FBezierPathBuilder.getConnectorOffset(target.x - source.x, offset);
+                break;
+            case EFConnectableSide.TOP:
+                result.y -= FBezierPathBuilder.getConnectorOffset(source.y - target.y, offset);
+                break;
+            case EFConnectableSide.BOTTOM:
+                result.y += FBezierPathBuilder.getConnectorOffset(target.y - source.y, offset);
+                break;
+        }
+        return result;
+    }
+    handle(request) {
+        const { source, sourceSide, target, targetSide, offset } = request;
+        const sourceAnglePoint = FBezierPathBuilder.getAnglePoint(sourceSide, source, target, offset);
+        const targetAnglePoint = FBezierPathBuilder.getAnglePoint(targetSide, target, source, offset);
+        const path = `M ${source.x} ${source.y} C ${sourceAnglePoint.x} ${sourceAnglePoint.y}, ${targetAnglePoint.x} ${targetAnglePoint.y}, ${target.x + 0.0002} ${target.y + 0.0002}`;
+        const connectionCenter = new CalculateConnectionCenterHandler().handle(new CalculateConnectionCenterRequest([source, sourceAnglePoint, targetAnglePoint, target]));
+        return { path, connectionCenter, penultimatePoint: targetAnglePoint };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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