@foblex/flow 12.6.7 → 16.0.0

package/esm2022/domain/subscribe-on-transform-changes/subscribe-on-transform-changes.execution.mjs

@@ -0,0 +1,25 @@
+import { __decorate } from "tslib";
+import { SubscribeOnTransformChangesRequest } from './subscribe-on-transform-changes.request';
+import { Injectable } from '@angular/core';
+import { merge } from 'rxjs';
+import { FExecutionRegister } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-storage";
+export let SubscribeOnTransformChangesExecution = class SubscribeOnTransformChangesExecution {
+    constructor(fTransformStore, fComponentsStore) {
+        this.fTransformStore = fTransformStore;
+        this.fComponentsStore = fComponentsStore;
+    }
+    handle(request) {
+        return merge(this.fTransformStore.changes, this.fComponentsStore.componentsData$, this.fComponentsStore.componentsCount$);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubscribeOnTransformChangesExecution, deps: [{ token: i1.FTransformStore }, { token: i1.FComponentsStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubscribeOnTransformChangesExecution }); }
+};
+SubscribeOnTransformChangesExecution = __decorate([
+    FExecutionRegister(SubscribeOnTransformChangesRequest)
+], SubscribeOnTransformChangesExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubscribeOnTransformChangesExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FTransformStore }, { type: i1.FComponentsStore }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/update-item-and-children-layers/move-front-elements-before-target-element/move-front-elements-before-target-element.execution.mjs

@@ -0,0 +1,29 @@
+import { __decorate } from "tslib";
+import { MoveFrontElementsBeforeTargetElementRequest } from './move-front-elements-before-target-element.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export let MoveFrontElementsBeforeTargetElementExecution = class MoveFrontElementsBeforeTargetElementExecution {
+    handle(request) {
+        const elementsToMove = [];
+        for (let i = request.targetIndex + 1; i < request.allElements.length; i++) {
+            const element = request.allElements[i];
+            if (!request.elementsThatShouldBeInFront.includes(element)) {
+                elementsToMove.push(element);
+            }
+        }
+        elementsToMove.forEach((x) => {
+            request.fItemsContainer.removeChild(x);
+            request.fItemsContainer.insertBefore(x, request.allElements[request.targetIndex]);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MoveFrontElementsBeforeTargetElementExecution, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MoveFrontElementsBeforeTargetElementExecution }); }
+};
+MoveFrontElementsBeforeTargetElementExecution = __decorate([
+    FExecutionRegister(MoveFrontElementsBeforeTargetElementRequest)
+], MoveFrontElementsBeforeTargetElementExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MoveFrontElementsBeforeTargetElementExecution, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/domain/update-item-and-children-layers/update-item-and-children-layers.execution.mjs

@@ -0,0 +1,93 @@
+import { __decorate } from "tslib";
+import { UpdateItemAndChildrenLayersRequest } from './update-item-and-children-layers.request';
+import { Injectable } from '@angular/core';
+import { FExecutionRegister } from '@foblex/mediator';
+import { GetDeepChildrenNodesAndGroupsRequest } from '../get-deep-children-nodes-and-groups';
+import { MoveFrontElementsBeforeTargetElementRequest } from './move-front-elements-before-target-element';
+import * as i0 from "@angular/core";
+import * as i1 from "../../f-storage";
+import * as i2 from "@foblex/mediator";
+export let UpdateItemAndChildrenLayersExecution = class UpdateItemAndChildrenLayersExecution {
+    get fGroupsContainer() {
+        return this.fComponentsStore.fCanvas.fGroupsContainer.nativeElement;
+    }
+    get fNodesContainer() {
+        return this.fComponentsStore.fCanvas.fNodesContainer.nativeElement;
+    }
+    get fConnectionsContainer() {
+        return this.fComponentsStore.fCanvas.fConnectionsContainer.nativeElement;
+    }
+    constructor(fComponentsStore, fMediator) {
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+    }
+    handle(request) {
+        switch (request.itemContainer) {
+            case this.fGroupsContainer:
+                this.handleGroup(request);
+                break;
+            case this.fNodesContainer:
+                this.handleNode(request);
+                break;
+            case this.fConnectionsContainer:
+                this.handleConnection(request);
+                break;
+            default:
+                throw new Error('Unknown container');
+        }
+    }
+    handleGroup(request) {
+        const childrenNodesAndGroups = this.getChildrenNodesAndGroups(request.item.fId);
+        const childrenGroups = this.getChildrenGroups(childrenNodesAndGroups);
+        this.updateLayers(this.fGroupsContainer, request.item.hostElement, childrenGroups);
+        const childrenNodes = this.getChildrenNodes(childrenNodesAndGroups);
+        if (childrenNodes.length) {
+            this.updateLayers(this.fNodesContainer, childrenNodes[0], childrenNodes);
+        }
+    }
+    handleNode(request) {
+        const childrenNodesAndGroups = this.getChildrenNodesAndGroups(request.item.fId);
+        const childrenNodes = this.getChildrenNodes(childrenNodesAndGroups);
+        this.updateLayers(request.itemContainer, request.item.hostElement, childrenNodes);
+    }
+    handleConnection(request) {
+        this.updateLayers(request.itemContainer, request.item.hostElement, []);
+    }
+    updateLayers(itemContainer, item, elementsThatShouldBeInFront) {
+        const allElements = Array.from(itemContainer.children);
+        const targetIndex = allElements.findIndex((x) => x === item);
+        if (this.isAnythingNeedToBeMoved(allElements, targetIndex, elementsThatShouldBeInFront)) {
+            this.fMediator.send(new MoveFrontElementsBeforeTargetElementRequest(itemContainer, allElements, elementsThatShouldBeInFront, targetIndex));
+        }
+    }
+    isAnythingNeedToBeMoved(allElements, targetIndex, elementsThatShouldBeInFront) {
+        for (let i = targetIndex + 1; i < allElements.length; i++) {
+            if (!elementsThatShouldBeInFront.includes(allElements[i])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getChildrenGroups(elements) {
+        const allElements = Array.from(this.fGroupsContainer.children);
+        return elements.filter((x) => this.fGroupsContainer.contains(x))
+            .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));
+    }
+    getChildrenNodes(elements) {
+        const allElements = Array.from(this.fNodesContainer.children);
+        return elements.filter((x) => this.fNodesContainer.contains(x))
+            .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));
+    }
+    getChildrenNodesAndGroups(fId) {
+        return this.fMediator.send(new GetDeepChildrenNodesAndGroupsRequest(fId)).map((x) => x.hostElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UpdateItemAndChildrenLayersExecution, deps: [{ token: i1.FComponentsStore }, { token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UpdateItemAndChildrenLayersExecution }); }
+};
+UpdateItemAndChildrenLayersExecution = __decorate([
+    FExecutionRegister(UpdateItemAndChildrenLayersRequest)
+], UpdateItemAndChildrenLayersExecution);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UpdateItemAndChildrenLayersExecution, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.FComponentsStore }, { type: i2.FMediator }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-item-and-children-layers.execution.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/domain/update-item-and-children-layers/update-item-and-children-layers.execution.ts"],"names":[],"mappings":"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","sourcesContent":["import { UpdateItemAndChildrenLayersRequest } from './update-item-and-children-layers.request';\nimport { Injectable } from '@angular/core';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FComponentsStore } from '../../f-storage';\nimport { FNodeBase } from '../../f-node';\nimport { GetDeepChildrenNodesAndGroupsRequest } from '../get-deep-children-nodes-and-groups';\nimport { MoveFrontElementsBeforeTargetElementRequest } from './move-front-elements-before-target-element';\n\n@Injectable()\n@FExecutionRegister(UpdateItemAndChildrenLayersRequest)\nexport class UpdateItemAndChildrenLayersExecution implements IExecution<UpdateItemAndChildrenLayersRequest, void> {\n\n  private get fGroupsContainer(): HTMLElement {\n    return this.fComponentsStore.fCanvas!.fGroupsContainer.nativeElement;\n  }\n\n  private get fNodesContainer(): HTMLElement {\n    return this.fComponentsStore.fCanvas!.fNodesContainer.nativeElement;\n  }\n\n  private get fConnectionsContainer(): HTMLElement {\n    return this.fComponentsStore.fCanvas!.fConnectionsContainer.nativeElement;\n  }\n\n  constructor(\n    private fComponentsStore: FComponentsStore,\n    private fMediator: FMediator\n  ) {\n  }\n\n  public handle(request: UpdateItemAndChildrenLayersRequest): void {\n\n    switch (request.itemContainer) {\n      case this.fGroupsContainer:\n        this.handleGroup(request);\n        break;\n      case this.fNodesContainer:\n        this.handleNode(request);\n        break;\n      case this.fConnectionsContainer:\n        this.handleConnection(request);\n        break;\n      default:\n        throw new Error('Unknown container');\n    }\n  }\n\n  private handleGroup(request: UpdateItemAndChildrenLayersRequest): void {\n    const childrenNodesAndGroups = this.getChildrenNodesAndGroups(request.item.fId);\n    const childrenGroups = this.getChildrenGroups(childrenNodesAndGroups);\n    this.updateLayers(this.fGroupsContainer, request.item.hostElement as HTMLElement, childrenGroups);\n    const childrenNodes = this.getChildrenNodes(childrenNodesAndGroups);\n    if (childrenNodes.length) {\n      this.updateLayers(this.fNodesContainer, childrenNodes[ 0 ], childrenNodes);\n    }\n  }\n\n  private handleNode(request: UpdateItemAndChildrenLayersRequest): void {\n    const childrenNodesAndGroups = this.getChildrenNodesAndGroups(request.item.fId);\n    const childrenNodes = this.getChildrenNodes(childrenNodesAndGroups);\n    this.updateLayers(request.itemContainer, request.item.hostElement as HTMLElement, childrenNodes);\n  }\n\n  private handleConnection(request: UpdateItemAndChildrenLayersRequest): void {\n    this.updateLayers(request.itemContainer, request.item.hostElement as HTMLElement, []);\n  }\n\n  private updateLayers(itemContainer: HTMLElement, item: HTMLElement, elementsThatShouldBeInFront: HTMLElement[]): void {\n    const allElements = Array.from(itemContainer.children) as HTMLElement[];\n    const targetIndex = allElements.findIndex((x) => x === item);\n    if (this.isAnythingNeedToBeMoved(allElements, targetIndex, elementsThatShouldBeInFront)) {\n      this.fMediator.send(\n        new MoveFrontElementsBeforeTargetElementRequest(itemContainer, allElements, elementsThatShouldBeInFront, targetIndex)\n      );\n    }\n  }\n\n  private isAnythingNeedToBeMoved(allElements: HTMLElement[], targetIndex: number, elementsThatShouldBeInFront: HTMLElement[]): boolean {\n    for (let i = targetIndex + 1; i < allElements.length; i++) {\n      if (!elementsThatShouldBeInFront.includes(allElements[ i ])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private getChildrenGroups(elements: HTMLElement[]): HTMLElement[] {\n    const allElements = Array.from(this.fGroupsContainer.children) as HTMLElement[];\n    return elements.filter((x) => this.fGroupsContainer.contains(x))\n      .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));\n  }\n\n  private getChildrenNodes(elements: HTMLElement[]): HTMLElement[] {\n    const allElements = Array.from(this.fNodesContainer.children) as HTMLElement[];\n    return elements.filter((x) => this.fNodesContainer.contains(x))\n      .sort((a, b) => allElements.indexOf(a) - allElements.indexOf(b));\n  }\n\n  private getChildrenNodesAndGroups(fId: string): HTMLElement[] {\n    return this.fMediator.send<FNodeBase[]>(new GetDeepChildrenNodesAndGroupsRequest(fId)).map((x) => x.hostElement);\n  }\n}\n"]}

package/{esm2015/f-backgroud/f-background-base.js → esm2022/f-backgroud/f-background-base.mjs}

@@ -2,10 +2,10 @@ import { Directive, InjectionToken } from '@angular/core';
 import * as i0 from "@angular/core";
 export const F_BACKGROUND = new InjectionToken('F_BACKGROUND');
 export class FBackgroundBase {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FBackgroundBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FBackgroundBase, ngImport: i0 }); }
 }
-FBackgroundBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FBackgroundBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-FBackgroundBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: FBackgroundBase, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FBackgroundBase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FBackgroundBase, decorators: [{
             type: Directive
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1iYWNrZ3JvdW5kLWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtYmFja2dyb3VkL2YtYmFja2dyb3VuZC1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUkxRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWtCLGNBQWMsQ0FBQyxDQUFDO0FBR2hGLE1BQU0sT0FBZ0IsZUFBZTs7NkdBQWYsZUFBZTtpR0FBZixlQUFlOzRGQUFmLGVBQWU7a0JBRHBDLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJVHJhbnNmb3JtTW9kZWwgfSBmcm9tICdAZm9ibGV4LzJkJztcbmltcG9ydCB7IElIYXNIb3N0RWxlbWVudCB9IGZyb20gJy4uL2ktaGFzLWhvc3QtZWxlbWVudCc7XG5cbmV4cG9ydCBjb25zdCBGX0JBQ0tHUk9VTkQgPSBuZXcgSW5qZWN0aW9uVG9rZW48RkJhY2tncm91bmRCYXNlPignRl9CQUNLR1JPVU5EJyk7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZCYWNrZ3JvdW5kQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICBwdWJsaWMgYWJzdHJhY3QgaXNCYWNrZ3JvdW5kRWxlbWVudChlbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQpOiBib29sZWFuO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBzZXRUcmFuc2Zvcm0odHJhbnNmb3JtOiBJVHJhbnNmb3JtTW9kZWwpOiB2b2lkO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1iYWNrZ3JvdW5kLWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtYmFja2dyb3VkL2YtYmFja2dyb3VuZC1iYXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUkxRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLENBQWtCLGNBQWMsQ0FBQyxDQUFDO0FBR2hGLE1BQU0sT0FBZ0IsZUFBZTsrR0FBZixlQUFlO21HQUFmLGVBQWU7OzRGQUFmLGVBQWU7a0JBRHBDLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBJVHJhbnNmb3JtTW9kZWwgfSBmcm9tICdAZm9ibGV4LzJkJztcbmltcG9ydCB7IElIYXNIb3N0RWxlbWVudCB9IGZyb20gJy4uL2ktaGFzLWhvc3QtZWxlbWVudCc7XG5cbmV4cG9ydCBjb25zdCBGX0JBQ0tHUk9VTkQgPSBuZXcgSW5qZWN0aW9uVG9rZW48RkJhY2tncm91bmRCYXNlPignRl9CQUNLR1JPVU5EJyk7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZCYWNrZ3JvdW5kQmFzZSBpbXBsZW1lbnRzIElIYXNIb3N0RWxlbWVudCB7XG5cbiAgcHVibGljIGFic3RyYWN0IGhvc3RFbGVtZW50OiBIVE1MRWxlbWVudDtcblxuICBwdWJsaWMgYWJzdHJhY3QgaXNCYWNrZ3JvdW5kRWxlbWVudChlbGVtZW50OiBIVE1MRWxlbWVudCB8IFNWR0VsZW1lbnQpOiBib29sZWFuO1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBzZXRUcmFuc2Zvcm0odHJhbnNmb3JtOiBJVHJhbnNmb3JtTW9kZWwpOiB2b2lkO1xufVxuIl19

package/esm2022/f-backgroud/f-background.component.mjs

@@ -0,0 +1,45 @@
+import { ChangeDetectionStrategy, Component, ContentChild } from "@angular/core";
+import { F_BACKGROUND, FBackgroundBase } from './f-background-base';
+import { F_BACKGROUND_PATTERN } from './domain';
+import { AddPatternToBackgroundRequest } from '../domain';
+import * as i0 from "@angular/core";
+import * as i1 from "../f-storage";
+import * as i2 from "@foblex/mediator";
+export class FBackgroundComponent extends FBackgroundBase {
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    constructor(elementReference, fComponentsStore, fMediator) {
+        super();
+        this.elementReference = elementReference;
+        this.fComponentsStore = fComponentsStore;
+        this.fMediator = fMediator;
+    }
+    ngOnInit() {
+        this.fComponentsStore.fBackground = this;
+    }
+    ngAfterContentInit() {
+        this.fMediator.send(new AddPatternToBackgroundRequest(this.fBackgroundPattern));
+    }
+    isBackgroundElement(element) {
+        return this.hostElement.contains(element);
+    }
+    setTransform(transform) {
+        this.fBackgroundPattern?.setTransform(transform);
+    }
+    ngOnDestroy() {
+        this.fComponentsStore.fBackground = undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FBackgroundComponent, deps: [{ token: i0.ElementRef }, { token: i1.FComponentsStore }, { token: i2.FMediator }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FBackgroundComponent, selector: "f-background", host: { classAttribute: "f-component f-background" }, providers: [{ provide: F_BACKGROUND, useExisting: FBackgroundComponent }], queries: [{ propertyName: "fBackgroundPattern", first: true, predicate: F_BACKGROUND_PATTERN, descendants: true }], usesInheritance: true, ngImport: i0, template: "<svg><ng-content></ng-content></svg>", isInline: true, styles: [":host{position:absolute;width:100%;height:100%;left:0;top:0;transform-origin:0 0;pointer-events:none}:host svg{width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FBackgroundComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "f-background", template: "<svg><ng-content></ng-content></svg>", host: {
+                        'class': 'f-component f-background'
+                    }, providers: [{ provide: F_BACKGROUND, useExisting: FBackgroundComponent }], changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{position:absolute;width:100%;height:100%;left:0;top:0;transform-origin:0 0;pointer-events:none}:host svg{width:100%;height:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.FComponentsStore }, { type: i2.FMediator }]; }, propDecorators: { fBackgroundPattern: [{
+                type: ContentChild,
+                args: [F_BACKGROUND_PATTERN, { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-backgroud/f-circle-pattern/f-circle-pattern.component.mjs

@@ -0,0 +1,104 @@
+import { ChangeDetectionStrategy, Component, Input } from "@angular/core";
+import { PointExtensions, TransformModelExtensions } from '@foblex/2d';
+import { F_BACKGROUND_PATTERN } from '../domain';
+import { createSVGElement } from '../../domain';
+import { Subject, Subscription } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@foblex/platform";
+let uniqueId = 0;
+export class FCirclePatternComponent {
+    get hostElement() {
+        return this.elementReference.nativeElement;
+    }
+    set color(value) {
+        this._color = value;
+        this._stateChanges.next();
+    }
+    set radius(value) {
+        this._radius = value;
+        this._stateChanges.next();
+    }
+    constructor(elementReference, fBrowser) {
+        this.elementReference = elementReference;
+        this.fBrowser = fBrowser;
+        this._subscription$ = new Subscription();
+        this._stateChanges = new Subject();
+        this.id = `f-pattern-${uniqueId++}`;
+        this._color = 'rgba(0,0,0,0.1)';
+        this._radius = 20;
+        this._scaledRadius = 20;
+        this._transform = TransformModelExtensions.default();
+        this._position = PointExtensions.initialize();
+        this.createPattern();
+    }
+    createPattern() {
+        this._pattern = createSVGElement('pattern', this.fBrowser);
+        this._pattern.setAttribute('patternUnits', 'userSpaceOnUse');
+        this.hostElement.appendChild(this._pattern);
+        this._circle = createSVGElement('circle', this.fBrowser);
+        this._pattern.appendChild(this._circle);
+    }
+    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._scaledRadius = this._radius * this._transform.scale;
+    }
+    redraw() {
+        this.calculatePattern();
+        this.redrawPattern();
+        this.redrawElement();
+    }
+    redrawPattern() {
+        this._pattern.setAttribute('x', `${this._position.x}`);
+        this._pattern.setAttribute('y', `${this._position.y}`);
+        this._pattern.setAttribute('width', `${this._scaledRadius}`);
+        this._pattern.setAttribute('height', `${this._scaledRadius}`);
+    }
+    redrawElement() {
+        this._circle.setAttribute('fill', this._color);
+        this._circle.setAttribute('cx', `${this._scaledRadius / 2}`);
+        this._circle.setAttribute('cy', `${this._scaledRadius / 2}`);
+        this._circle.setAttribute('r', `${this._scaledRadius / this._radius}`);
+    }
+    setTransform(transform) {
+        this._transform = transform;
+        this._stateChanges.next();
+    }
+    ngOnDestroy() {
+        this._subscription$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FCirclePatternComponent, deps: [{ token: i0.ElementRef }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FCirclePatternComponent, selector: "f-circle-pattern", inputs: { id: "id", color: "color", radius: "radius" }, host: { properties: { "attr.id": "id" } }, providers: [
+            { provide: F_BACKGROUND_PATTERN, useExisting: FCirclePatternComponent }
+        ], ngImport: i0, template: ``, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FCirclePatternComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "f-circle-pattern",
+                    template: ``,
+                    host: {
+                        '[attr.id]': 'id'
+                    },
+                    providers: [
+                        { provide: F_BACKGROUND_PATTERN, useExisting: FCirclePatternComponent }
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.BrowserService }]; }, propDecorators: { id: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], radius: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-circle-pattern.component.js","sourceRoot":"","sources":["../../../../../projects/f-flow/src/f-backgroud/f-circle-pattern/f-circle-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,\n  ITransformModel,\n  PointExtensions,\n  TransformModelExtensions\n} from '@foblex/2d';\nimport { F_BACKGROUND_PATTERN, IFBackgroundPattern } from '../domain';\nimport { BrowserService } from '@foblex/platform';\nimport { createSVGElement } from '../../domain';\nimport { Subject, Subscription } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\n\nlet uniqueId: number = 0;\n\n@Component({\n  selector: \"f-circle-pattern\",\n  template: ``,\n  host: {\n    '[attr.id]': 'id'\n  },\n  providers: [\n    { provide: F_BACKGROUND_PATTERN, useExisting: FCirclePatternComponent }\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class FCirclePatternComponent 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\n  private _color: string = 'rgba(0,0,0,0.1)';\n\n  @Input()\n  public set color(value: string) {\n    this._color = value;\n    this._stateChanges.next();\n  }\n\n  private _radius: number = 20;\n  private _scaledRadius: number = 20;\n\n  @Input()\n  public set radius(value: number) {\n    this._radius = value;\n    this._stateChanges.next();\n  }\n\n  private _transform: ITransformModel = TransformModelExtensions.default();\n\n  private _position: IPoint = PointExtensions.initialize();\n\n  private _pattern!: SVGPatternElement;\n  private _circle!: SVGCircleElement;\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._circle = createSVGElement('circle', this.fBrowser);\n    this._pattern.appendChild(this._circle);\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._scaledRadius = this._radius * this._transform.scale;\n  }\n\n  private redraw(): void {\n    this.calculatePattern();\n    this.redrawPattern();\n    this.redrawElement();\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._scaledRadius }`);\n    this._pattern.setAttribute('height', `${ this._scaledRadius }`);\n  }\n\n  private redrawElement(): void {\n    this._circle.setAttribute('fill', this._color);\n    this._circle.setAttribute('cx', `${ this._scaledRadius / 2 }`);\n    this._circle.setAttribute('cy', `${ this._scaledRadius / 2 }`);\n    this._circle.setAttribute('r', `${ this._scaledRadius / this._radius }`);\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/esm2022/f-backgroud/f-rect-pattern/f-rect-pattern.component.mjs

@@ -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 {
+    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();
+    }
+    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();
+    }
+    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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FRectPatternComponent, deps: [{ token: i0.ElementRef }, { token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", 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: "16.2.12", 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/f-canvas-base.js → esm2022/f-canvas/f-canvas-base.mjs}

@@ -16,10 +16,10 @@ export class FCanvasBase {
     emitCanvasChangeEvent() {
         this.fCanvasChange.emit(new FCanvasChangeEvent(PointExtensions.sum(this.transform.position, this.transform.scaledPosition), this.transform.scale));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FCanvasBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FCanvasBase, ngImport: i0 }); }
 }
-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, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: FCanvasBase, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FCanvasBase, decorators: [{
             type: Directive
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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