@foblex/flow 18.2.0 → 18.3.0

package/esm2022/f-flow.module.mjs

@@ -18,43 +18,44 @@ import { F_VIRTUAL_FOR_PROVIDERS } from './f-virtual';
 import * as i0 from "@angular/core";
 import * as i1 from "./f-connection-v2/components/connection-drag-handles/f-connection-drag-handle-start";
 import * as i2 from "./f-connection-v2/components/connection-drag-handles/f-connection-drag-handle-end";
-import * as i3 from "./f-connection-v2/components/connection-gradient/f-connection-gradient";
-import * as i4 from "./f-connection-v2/components/connection-path/f-connection-path";
-import * as i5 from "./f-connection-v2/components/connection-selection/f-connection-selection";
-import * as i6 from "./f-connection-v2/components/connection-marker/f-connection-marker";
-import * as i7 from "./f-connection/f-connection/f-connection.component";
-import * as i8 from "./f-connection/f-connection-for-create/f-connection-for-create.component";
-import * as i9 from "./f-connection/f-snap-connection/f-snap-connection.component";
-import * as i10 from "./f-connectors/f-node-input/f-node-input.directive";
-import * as i11 from "./f-connectors/f-node-outlet/f-node-outlet.directive";
-import * as i12 from "./f-connectors/f-node-output/f-node-output.directive";
-import * as i13 from "./f-line-alignment/f-line-alignment.component";
-import * as i14 from "./f-node/f-group.directive";
-import * as i15 from "./f-node/f-node.directive";
-import * as i16 from "./f-node/f-drag-handle.directive";
-import * as i17 from "./f-node/f-resize-handle/f-resize-handle.directive";
-import * as i18 from "./f-node/f-rotate-handle/f-rotate-handle.directive";
-import * as i19 from "./f-flow/f-flow.component";
-import * as i20 from "./f-canvas/f-canvas.component";
-import * as i21 from "./f-backgroud/f-background.component";
-import * as i22 from "./f-backgroud/f-rect-pattern/f-rect-pattern.component";
-import * as i23 from "./f-backgroud/f-circle-pattern/f-circle-pattern.component";
-import * as i24 from "./f-zoom/f-zoom.directive";
-import * as i25 from "./f-external-item/f-external-item";
-import * as i26 from "./f-minimap/f-minimap.component";
-import * as i27 from "./f-minimap/f-minimap-canvas.directive";
-import * as i28 from "./f-minimap/f-minimap-view.directive";
-import * as i29 from "./f-minimap/f-minimap-flow.directive";
-import * as i30 from "./f-selection-area/f-selection-area";
-import * as i31 from "./f-magnetic-lines/f-magnetic-lines";
-import * as i32 from "./f-magnetic-rects/f-magnetic-rects";
-import * as i33 from "./f-connection-v2/components/connection-content/f-connection-content";
-import * as i34 from "./f-connection-v2/components/connection-waypoints/f-connection-waypoints";
-import * as i35 from "./f-virtual/f-virtual-for";
+import * as i3 from "./f-connection-v2/components/connection-path/f-connection-path";
+import * as i4 from "./f-connection-v2/components/connection-selection/f-connection-selection";
+import * as i5 from "./f-connection-v2/components/connection-marker/f-connection-marker";
+import * as i6 from "./f-connection/f-connection/f-connection.component";
+import * as i7 from "./f-connection/f-connection-for-create/f-connection-for-create.component";
+import * as i8 from "./f-connection/f-snap-connection/f-snap-connection.component";
+import * as i9 from "./f-connectors/f-node-input/f-node-input.directive";
+import * as i10 from "./f-connectors/f-node-outlet/f-node-outlet.directive";
+import * as i11 from "./f-connectors/f-node-output/f-node-output.directive";
+import * as i12 from "./f-line-alignment/f-line-alignment.component";
+import * as i13 from "./f-node/f-group.directive";
+import * as i14 from "./f-node/f-node.directive";
+import * as i15 from "./f-node/f-drag-handle.directive";
+import * as i16 from "./f-node/f-resize-handle/f-resize-handle.directive";
+import * as i17 from "./f-node/f-rotate-handle/f-rotate-handle.directive";
+import * as i18 from "./f-flow/f-flow.component";
+import * as i19 from "./f-canvas/f-canvas.component";
+import * as i20 from "./f-backgroud/f-background.component";
+import * as i21 from "./f-backgroud/f-rect-pattern/f-rect-pattern.component";
+import * as i22 from "./f-backgroud/f-circle-pattern/f-circle-pattern.component";
+import * as i23 from "./f-zoom/f-zoom.directive";
+import * as i24 from "./f-external-item/f-external-item";
+import * as i25 from "./f-minimap/f-minimap.component";
+import * as i26 from "./f-minimap/f-minimap-canvas.directive";
+import * as i27 from "./f-minimap/f-minimap-view.directive";
+import * as i28 from "./f-minimap/f-minimap-flow.directive";
+import * as i29 from "./f-selection-area/f-selection-area";
+import * as i30 from "./f-magnetic-lines/f-magnetic-lines";
+import * as i31 from "./f-magnetic-rects/f-magnetic-rects";
+import * as i32 from "./f-connection-v2/components/connection-content/f-connection-content";
+import * as i33 from "./f-connection-v2/components/connection-gradient/f-connection-gradient";
+import * as i34 from "./f-connection-v2/components/connection-gradient/components/render/f-connection-gradient-renderer";
+import * as i35 from "./f-connection-v2/components/connection-waypoints/f-connection-waypoints";
+import * as i36 from "./f-virtual/f-virtual-for";
 export class FFlowModule {
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFlowModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FFlowModule, declarations: [i1.FConnectionDragHandleStart, i2.FConnectionDragHandleEnd, i3.FConnectionGradient, i4.FConnectionPath, i5.FConnectionSelection, i6.FConnectionMarker, i7.FConnectionComponent, i8.FConnectionForCreateComponent, i9.FSnapConnectionComponent, i10.FNodeInputDirective, i11.FNodeOutletDirective, i12.FNodeOutputDirective, i13.FLineAlignmentComponent, i14.FGroupDirective, i15.FNodeDirective, i16.FDragHandleDirective, i17.FResizeHandleDirective, i18.FRotateHandleDirective, FDragBlockerDirective,
-            FDraggableDirective], imports: [i19.FFlowComponent, i20.FCanvasComponent, i21.FBackgroundComponent, i22.FRectPatternComponent, i23.FCirclePatternComponent, i24.FZoomDirective, i25.FExternalItem, i26.FMinimapComponent, i27.FMinimapCanvasDirective, i28.FMinimapViewDirective, i29.FMinimapFlowDirective, i30.FSelectionArea, i31.FMagneticLines, i32.FMagneticRects, i33.FConnectionContent, i34.FConnectionWaypoints, i35.FVirtualFor, CommonModule], exports: [i19.FFlowComponent, i20.FCanvasComponent, i21.FBackgroundComponent, i22.FRectPatternComponent, i23.FCirclePatternComponent, i24.FZoomDirective, i25.FExternalItem, i30.FSelectionArea, i31.FMagneticLines, i32.FMagneticRects, i33.FConnectionContent, i34.FConnectionWaypoints, i1.FConnectionDragHandleStart, i2.FConnectionDragHandleEnd, i3.FConnectionGradient, i4.FConnectionPath, i5.FConnectionSelection, i6.FConnectionMarker, i7.FConnectionComponent, i8.FConnectionForCreateComponent, i9.FSnapConnectionComponent, i10.FNodeInputDirective, i11.FNodeOutletDirective, i12.FNodeOutputDirective, i13.FLineAlignmentComponent, i26.FMinimapComponent, i27.FMinimapCanvasDirective, i28.FMinimapViewDirective, i29.FMinimapFlowDirective, i14.FGroupDirective, i15.FNodeDirective, i16.FDragHandleDirective, i17.FResizeHandleDirective, i18.FRotateHandleDirective, i35.FVirtualFor, FDragBlockerDirective,
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: FFlowModule, declarations: [i1.FConnectionDragHandleStart, i2.FConnectionDragHandleEnd, i3.FConnectionPath, i4.FConnectionSelection, i5.FConnectionMarker, i6.FConnectionComponent, i7.FConnectionForCreateComponent, i8.FSnapConnectionComponent, i9.FNodeInputDirective, i10.FNodeOutletDirective, i11.FNodeOutputDirective, i12.FLineAlignmentComponent, i13.FGroupDirective, i14.FNodeDirective, i15.FDragHandleDirective, i16.FResizeHandleDirective, i17.FRotateHandleDirective, FDragBlockerDirective,
+            FDraggableDirective], imports: [i18.FFlowComponent, i19.FCanvasComponent, i20.FBackgroundComponent, i21.FRectPatternComponent, i22.FCirclePatternComponent, i23.FZoomDirective, i24.FExternalItem, i25.FMinimapComponent, i26.FMinimapCanvasDirective, i27.FMinimapViewDirective, i28.FMinimapFlowDirective, i29.FSelectionArea, i30.FMagneticLines, i31.FMagneticRects, i32.FConnectionContent, i33.FConnectionGradient, i34.FConnectionGradientRenderer, i35.FConnectionWaypoints, i36.FVirtualFor, CommonModule], exports: [i18.FFlowComponent, i19.FCanvasComponent, i20.FBackgroundComponent, i21.FRectPatternComponent, i22.FCirclePatternComponent, i23.FZoomDirective, i24.FExternalItem, i29.FSelectionArea, i30.FMagneticLines, i31.FMagneticRects, i32.FConnectionContent, i33.FConnectionGradient, i34.FConnectionGradientRenderer, i35.FConnectionWaypoints, i1.FConnectionDragHandleStart, i2.FConnectionDragHandleEnd, i3.FConnectionPath, i4.FConnectionSelection, i5.FConnectionMarker, i6.FConnectionComponent, i7.FConnectionForCreateComponent, i8.FSnapConnectionComponent, i9.FNodeInputDirective, i10.FNodeOutletDirective, i11.FNodeOutputDirective, i12.FLineAlignmentComponent, i25.FMinimapComponent, i26.FMinimapCanvasDirective, i27.FMinimapViewDirective, i28.FMinimapFlowDirective, i13.FGroupDirective, i14.FNodeDirective, i15.FDragHandleDirective, i16.FResizeHandleDirective, i17.FRotateHandleDirective, i36.FVirtualFor, FDragBlockerDirective,
             FDraggableDirective] });
     static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFlowModule, imports: [CommonModule] });
 }
@@ -104,4 +105,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     ],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-storage/f-components-store.mjs

@@ -12,12 +12,17 @@ export class FComponentsStore {
     _connectionsRevision = 0;
     nodesChanges$ = new FChannel();
     _nodesRevision = 0;
+    progressiveRenderChanges$ = new FChannel();
+    _pendingProgressiveRenderCount = 0;
     get connectionsRevision() {
         return this._connectionsRevision;
     }
     get nodesRevision() {
         return this._nodesRevision;
     }
+    get hasPendingProgressiveRender() {
+        return this._pendingProgressiveRenderCount > 0;
+    }
     get flowHost() {
         return this.fFlow?.hostElement;
     }
@@ -42,6 +47,17 @@ export class FComponentsStore {
         this._connectionsRevision++;
         this.connectionsChanges$.notify();
     }
+    beginProgressiveRender() {
+        this._pendingProgressiveRenderCount++;
+        this.progressiveRenderChanges$.notify();
+    }
+    endProgressiveRender() {
+        if (!this._pendingProgressiveRenderCount) {
+            return;
+        }
+        this._pendingProgressiveRenderCount--;
+        this.progressiveRenderChanges$.notify();
+    }
     transformChanged() {
         this.transformChanges$.notify();
     }
@@ -65,4 +81,4 @@ export const INSTANCES = {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     MINIMAP: fInstanceKey('minimap'),
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-components-store.js","sourceRoot":"","sources":["../../../../projects/f-flow/src/f-storage/f-components-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAM3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC;;AAQ3D,MAAM,OAAO,gBAAgB;IACX,iBAAiB,GAAG,IAAI,QAAQ,EAAE,CAAC;IAEnC,mBAAmB,GAAG,IAAI,QAAQ,EAAE,CAAC;IAC7C,oBAAoB,GAAG,CAAC,CAAC;IAEjB,aAAa,GAAG,IAAI,QAAQ,EAAE,CAAC;IACvC,cAAc,GAAG,CAAC,CAAC;IAEX,yBAAyB,GAAG,IAAI,QAAQ,EAAE,CAAC;IACnD,8BAA8B,GAAG,CAAC,CAAC;IAE3C,IAAW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IAED,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,IAAW,2BAA2B;QACpC,OAAO,IAAI,CAAC,8BAA8B,GAAG,CAAC,CAAC;IACjD,CAAC;IAED,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,KAAK,EAAE,WAA0B,CAAC;IAChD,CAAC;IAEM,KAAK,CAAwB;IAE7B,OAAO,CAA0B;IAExC,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,OAAO,EAAE,SAA4B,CAAC;IACpD,CAAC;IAEe,KAAK,GAAG,IAAI,aAAa,EAAE,CAAC;IAC5B,WAAW,GAAG,IAAI,mBAAmB,EAAE,CAAC;IACxC,iBAAiB,GAAG,IAAI,yBAAyB,EAAE,CAAC;IAEpD,OAAO,GAAG,IAAI,kBAAkB,CAAkB,QAAQ,CAAC,CAAC;IAC5D,MAAM,GAAG,IAAI,kBAAkB,CAAiB,OAAO,CAAC,CAAC;IACzD,OAAO,GAAG,IAAI,kBAAkB,CAAkB,QAAQ,CAAC,CAAC;IAE5D,SAAS,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAE/C,UAAU,CAA6B;IAEvC,eAAe;QACpB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;IAC9B,CAAC;IAEM,qBAAqB;QAC1B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,CAAC;IACpC,CAAC;IAEM,sBAAsB;QAC3B,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACtC,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC;IAC1C,CAAC;IAEM,oBAAoB;QACzB,IAAI,CAAC,IAAI,CAAC,8BAA8B,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,8BAA8B,EAAE,CAAC;QACtC,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC;IAC1C,CAAC;IAEM,gBAAgB;QACrB,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC;IAClC,CAAC;wGA1EU,gBAAgB;4GAAhB,gBAAgB;;4FAAhB,gBAAgB;kBAD5B,UAAU;;AA8EX,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,gEAAgE;IAChE,cAAc,EAAE,YAAY,CAAqB,gBAAgB,CAAC;IAElE,gEAAgE;IAChE,cAAc,EAAE,YAAY,CAAqB,gBAAgB,CAAC;IAElE,gEAAgE;IAChE,IAAI,EAAE,YAAY,CAAY,eAAe,CAAC;IAE9C,gEAAgE;IAChE,UAAU,EAAE,YAAY,CAAkB,YAAY,CAAC;IAEvD,gEAAgE;IAChE,cAAc,EAAE,YAAY,CAAqB,gBAAgB,CAAC;IAElE,gEAAgE;IAChE,OAAO,EAAE,YAAY,CAAe,SAAS,CAAC;CACtC,CAAC","sourcesContent":["import { Injectable } from '@angular/core';\nimport { FFlowBase } from '../f-flow';\nimport { FCanvasBase } from '../f-canvas';\nimport { FBackgroundBase } from '../f-backgroud';\nimport { FNodeInputBase, FNodeOutletBase, FNodeOutputBase } from '../f-connectors';\nimport { FDraggableBase } from '../f-draggable';\nimport { FChannel } from '../reactivity';\nimport { ITransformModel } from '@foblex/2d';\nimport { FConnectorRegistry } from './f-connector-registry';\nimport { FNodeRegistry } from './f-node-registry';\nimport { FConnectionRegistry } from './f-connection-registry';\nimport { FConnectionMarkerRegistry } from './f-connection-marker-registry';\nimport { fInstanceKey, FSingleRegistryBase } from './base';\nimport { FZoomBase } from '../f-zoom';\nimport { FSelectionAreaBase } from '../f-selection-area';\nimport { FMagneticLinesBase } from '../f-magnetic-lines';\nimport { FMagneticRectsBase } from '../f-magnetic-rects';\nimport { FMinimapBase } from '../f-minimap';\n\n@Injectable()\nexport class FComponentsStore {\n  public readonly transformChanges$ = new FChannel();\n\n  public readonly connectionsChanges$ = new FChannel();\n  private _connectionsRevision = 0;\n\n  public readonly nodesChanges$ = new FChannel();\n  private _nodesRevision = 0;\n\n  public readonly progressiveRenderChanges$ = new FChannel();\n  private _pendingProgressiveRenderCount = 0;\n\n  public get connectionsRevision(): number {\n    return this._connectionsRevision;\n  }\n\n  public get nodesRevision(): number {\n    return this._nodesRevision;\n  }\n\n  public get hasPendingProgressiveRender(): boolean {\n    return this._pendingProgressiveRenderCount > 0;\n  }\n\n  public get flowHost(): HTMLElement {\n    return this.fFlow?.hostElement as HTMLElement;\n  }\n\n  public fFlow: FFlowBase | undefined;\n\n  public fCanvas: FCanvasBase | undefined;\n\n  public get transform(): ITransformModel {\n    return this.fCanvas?.transform as ITransformModel;\n  }\n\n  public readonly nodes = new FNodeRegistry();\n  public readonly connections = new FConnectionRegistry();\n  public readonly connectionMarkers = new FConnectionMarkerRegistry();\n\n  public readonly outputs = new FConnectorRegistry<FNodeOutputBase>('Output');\n  public readonly inputs = new FConnectorRegistry<FNodeInputBase>('Input');\n  public readonly outlets = new FConnectorRegistry<FNodeOutletBase>('Outlet');\n\n  public readonly instances = new FSingleRegistryBase();\n\n  public fDraggable: FDraggableBase | undefined;\n\n  public emitNodeChanges(): void {\n    this._nodesRevision++;\n    this.nodesChanges$.notify();\n  }\n\n  public emitConnectionChanges(): void {\n    this._connectionsRevision++;\n    this.connectionsChanges$.notify();\n  }\n\n  public beginProgressiveRender(): void {\n    this._pendingProgressiveRenderCount++;\n    this.progressiveRenderChanges$.notify();\n  }\n\n  public endProgressiveRender(): void {\n    if (!this._pendingProgressiveRenderCount) {\n      return;\n    }\n\n    this._pendingProgressiveRenderCount--;\n    this.progressiveRenderChanges$.notify();\n  }\n\n  public transformChanged(): void {\n    this.transformChanges$.notify();\n  }\n}\n\nexport const INSTANCES = {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  MAGNETIC_LINES: fInstanceKey<FMagneticLinesBase>('magnetic-lines'),\n\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  MAGNETIC_RECTS: fInstanceKey<FMagneticRectsBase>('magnetic-rects'),\n\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ZOOM: fInstanceKey<FZoomBase>('zoom-controls'),\n\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  BACKGROUND: fInstanceKey<FBackgroundBase>('background'),\n\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  SELECTION_AREA: fInstanceKey<FSelectionAreaBase>('selection-area'),\n\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  MINIMAP: fInstanceKey<FMinimapBase>('minimap'),\n} as const;\n"]}

package/esm2022/f-virtual/f-virtual-for.mjs

@@ -1,4 +1,5 @@
 import { Directive, inject, Input, NgZone, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { FComponentsStore } from '../f-storage';
 import * as i0 from "@angular/core";
 export class FVirtualFor {
     fVirtualForOf = [];
@@ -6,20 +7,32 @@ export class FVirtualFor {
     _vc = inject(ViewContainerRef);
     _tpl = inject(TemplateRef);
     _zone = inject(NgZone);
+    _componentsStore = inject(FComponentsStore, { optional: true });
     _views = [];
+    _rafId = null;
+    _isProgressiveRenderActive = false;
     ngOnChanges(changes) {
         if (changes['fVirtualForOf']) {
             this._reset();
             this._renderProgressively();
         }
     }
+    ngOnDestroy() {
+        this._reset();
+    }
     _reset() {
+        if (this._rafId !== null) {
+            cancelAnimationFrame(this._rafId);
+            this._rafId = null;
+        }
+        this._finishProgressiveRender();
         this._vc.clear();
         this._views.length = 0;
     }
     _renderProgressively() {
         const FRAME_BUDGET = 10; // ms
         let index = 0;
+        this._startProgressiveRender();
         this._zone.runOutsideAngular(() => {
             const pump = () => {
                 const start = performance.now();
@@ -33,12 +46,29 @@ export class FVirtualFor {
                     index++;
                 }
                 if (index < this.fVirtualForOf.length) {
-                    requestAnimationFrame(pump);
+                    this._rafId = requestAnimationFrame(pump);
+                    return;
                 }
+                this._rafId = null;
+                this._finishProgressiveRender();
             };
-            requestAnimationFrame(pump);
+            this._rafId = requestAnimationFrame(pump);
         });
     }
+    _startProgressiveRender() {
+        if (this._isProgressiveRenderActive) {
+            return;
+        }
+        this._isProgressiveRenderActive = true;
+        this._componentsStore?.beginProgressiveRender();
+    }
+    _finishProgressiveRender() {
+        if (!this._isProgressiveRenderActive) {
+            return;
+        }
+        this._isProgressiveRenderActive = false;
+        this._componentsStore?.endProgressiveRender();
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FVirtualFor, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FVirtualFor, isStandalone: true, selector: "[fVirtualFor][fVirtualForOf]", inputs: { fVirtualForOf: "fVirtualForOf", fVirtualForTrackBy: "fVirtualForTrackBy" }, usesOnChanges: true, ngImport: i0 });
 }
@@ -53,4 +83,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], fVirtualForTrackBy: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/f-connection/f-connection/f-connection.component.d.ts

@@ -20,7 +20,7 @@ export declare class FConnectionComponent extends FConnectionBase implements OnI
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; "isSignal": true; }; "fOutputId": { "alias": "fOutputId"; "required": false; "isSignal": true; }; "fInputId": { "alias": "fInputId"; "required": false; "isSignal": true; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; "isSignal": true; }; "fReassignableStart": { "alias": "fReassignableStart"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; "isSignal": true; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["*", "f-connection-waypoints", "[fConnectionContent]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionComponent, "f-connection", ["fComponent"], { "fId": { "alias": "fConnectionId"; "required": false; "isSignal": true; }; "fOutputId": { "alias": "fOutputId"; "required": false; "isSignal": true; }; "fInputId": { "alias": "fInputId"; "required": false; "isSignal": true; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fSelectionDisabled": { "alias": "fSelectionDisabled"; "required": false; "isSignal": true; }; "fReassignableStart": { "alias": "fReassignableStart"; "required": false; "isSignal": true; }; "fDraggingDisabled": { "alias": "fReassignDisabled"; "required": false; "isSignal": true; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["svg[fMarker]", "f-connection-gradient", "f-connection-waypoints", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;
     static ngAcceptInputType_fBehavior: unknown;

package/f-connection/f-connection-for-create/f-connection-for-create.component.d.ts

@@ -18,7 +18,7 @@ export declare class FConnectionForCreateComponent extends FConnectionBase imple
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionForCreateComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[fConnectionContent]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionForCreateComponent, "f-connection-for-create", never, { "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["svg[fMarker]", "f-connection-gradient", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;
     static ngAcceptInputType_fBehavior: unknown;

package/f-connection/f-snap-connection/f-snap-connection.component.d.ts

@@ -19,7 +19,7 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     ngOnChanges(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FSnapConnectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[fConnectionContent]"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FSnapConnectionComponent, "f-snap-connection", never, { "fSnapThreshold": { "alias": "fSnapThreshold"; "required": false; }; "fRadius": { "alias": "fRadius"; "required": false; }; "fOffset": { "alias": "fOffset"; "required": false; }; "fBehavior": { "alias": "fBehavior"; "required": false; }; "fType": { "alias": "fType"; "required": false; }; "fInputSide": { "alias": "fInputSide"; "required": false; "isSignal": true; }; "fOutputSide": { "alias": "fOutputSide"; "required": false; "isSignal": true; }; }, {}, never, ["svg[fMarker]", "f-connection-gradient", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fSnapThreshold: unknown;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;

package/f-connection/providers.d.ts

@@ -1,6 +1,6 @@
 import { FConnectionComponent } from './f-connection';
 import { FConnectionForCreateComponent } from './f-connection-for-create';
 import { FSnapConnectionComponent } from './f-snap-connection';
-import { FConnectionContent, FConnectionWaypoints, FConnectionDragHandleStart, FConnectionGradient, FConnectionMarker, FConnectionPath, FConnectionSelection } from '../f-connection-v2';
-export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionMarker | typeof FConnectionGradient | typeof FConnectionPath | typeof FConnectionSelection | typeof FConnectionDragHandleStart | typeof FConnectionComponent | typeof FConnectionForCreateComponent | typeof FSnapConnectionComponent)[];
-export declare const F_CONNECTION_IMPORTS_EXPORTS: (typeof FConnectionContent | typeof FConnectionWaypoints)[];
+import { FConnectionContent, FConnectionDragHandleStart, FConnectionGradient, FConnectionGradientRenderer, FConnectionMarker, FConnectionPath, FConnectionSelection, FConnectionWaypoints } from '../f-connection-v2';
+export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionMarker | typeof FConnectionPath | typeof FConnectionSelection | typeof FConnectionDragHandleStart | typeof FConnectionComponent | typeof FConnectionForCreateComponent | typeof FSnapConnectionComponent)[];
+export declare const F_CONNECTION_IMPORTS_EXPORTS: (typeof FConnectionContent | typeof FConnectionWaypoints | typeof FConnectionGradientRenderer | typeof FConnectionGradient)[];

package/f-connection-v2/components/connection-gradient/components/index.d.ts

@@ -0,0 +1 @@
+export * from './render';

package/f-connection-v2/components/connection-gradient/components/render/f-connection-gradient-renderer.d.ts

@@ -0,0 +1,8 @@
+import { FConnectionGradientRendererBase } from './models';
+import { FConnectionGradientBase } from '../../models';
+import * as i0 from "@angular/core";
+export declare class FConnectionGradientRenderer extends FConnectionGradientRendererBase {
+    readonly gradient: import("@angular/core").InputSignal<FConnectionGradientBase>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradientRenderer, "linearGradient[fConnectionGradientRenderer]", never, { "gradient": { "alias": "fConnectionGradientRendererFor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/f-connection-v2/components/connection-gradient/components/render/index.d.ts

@@ -0,0 +1,2 @@
+export * from './models';
+export * from './f-connection-gradient-renderer';

package/f-connection-v2/components/connection-gradient/components/render/models/f-connection-gradient-renderer-base.d.ts

@@ -0,0 +1,25 @@
+import { InputSignal, OnInit } from '@angular/core';
+import { ILine } from '@foblex/2d';
+import { FConnectionGradientBase } from '../../../models';
+import * as i0 from "@angular/core";
+export declare abstract class FConnectionGradientRendererBase implements OnInit {
+    private readonly _connection;
+    private readonly _hostElement;
+    private readonly _injector;
+    private readonly _hostAttributes;
+    private _startColor?;
+    private _endColor?;
+    abstract gradient: InputSignal<FConnectionGradientBase>;
+    readonly gradientId: import("@angular/core").Signal<string>;
+    ngOnInit(): void;
+    private _listenColorChanges;
+    get stop1Element(): SVGStopElement;
+    get stop2Element(): SVGStopElement;
+    redraw(line: ILine): void;
+    private _updateGradient;
+    private _setFromColor;
+    private _setToColor;
+    private _setHostAttribute;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradientRendererBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionGradientRendererBase, never, never, {}, {}, never, never, false, never>;
+}

package/f-connection-v2/components/connection-gradient/components/render/models/index.d.ts

@@ -0,0 +1 @@
+export * from './f-connection-gradient-renderer-base';

package/f-connection-v2/components/connection-gradient/f-connection-gradient.d.ts

@@ -1,16 +1,8 @@
-import { ILine } from '@foblex/2d';
 import { FConnectionGradientBase } from './models';
 import * as i0 from "@angular/core";
 export declare class FConnectionGradient extends FConnectionGradientBase {
-    private readonly _connection;
-    get gradientId(): string;
-    get stop1Element(): SVGStopElement;
-    get stop2Element(): SVGStopElement;
-    initialize(): void;
-    private _updateGradient;
-    private _setFromColor;
-    private _setToColor;
-    redraw(line: ILine): void;
+    readonly fStartColor: import("@angular/core").InputSignal<string>;
+    readonly fEndColor: import("@angular/core").InputSignal<string>;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionGradient, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradient, "linearGradient[fConnectionGradient]", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionGradient, "f-connection-gradient", never, { "fStartColor": { "alias": "fStartColor"; "required": true; "isSignal": true; }; "fEndColor": { "alias": "fEndColor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/f-connection-v2/components/connection-gradient/index.d.ts

@@ -1,2 +1,3 @@
+export * from './components';
 export * from './models';
 export * from './f-connection-gradient';

package/f-connection-v2/components/connection-gradient/models/f-connection-gradient-base.d.ts

@@ -1,8 +1,6 @@
-import { ILine } from '@foblex/2d';
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
 export declare const F_CONNECTION_GRADIENT: InjectionToken<FConnectionGradientBase>;
 export declare abstract class FConnectionGradientBase {
-    readonly hostElement: any;
-    abstract initialize(): void;
-    abstract redraw(line: ILine): void;
+    abstract fStartColor: Signal<string>;
+    abstract fEndColor: Signal<string>;
 }

package/f-connection-v2/components/connection-path/f-connection-path.d.ts

@@ -2,13 +2,14 @@ import { FConnectionPathBase } from './models';
 import * as i0 from "@angular/core";
 export declare class FConnectionPath extends FConnectionPathBase {
     private readonly _connection;
+    readonly useGradient: import("@angular/core").InputSignal<boolean>;
+    readonly linkToGradient: import("@angular/core").Signal<string | null>;
     get fPathId(): string;
-    get linkToGradient(): string;
     get attrConnectionId(): string;
     initialize(): void;
     setPath(path: string): void;
     select(): void;
     deselect(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionPath, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPath, "path[f-connection-path]", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FConnectionPath, "path[f-connection-path]", never, { "useGradient": { "alias": "useGradient"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
 }

package/f-connection-v2/components/f-connection-base.d.ts

@@ -13,8 +13,6 @@ declare const MIXIN_BASE: import("../../mixins").Constructor<ISelectable> & impo
 export declare abstract class FConnectionBase extends MIXIN_BASE implements ISelectable, ICanChangeVisibility {
     private readonly _fConnectionBuilder;
     abstract fId: Signal<string>;
-    readonly fStartColor: import("@angular/core").InputSignal<string>;
-    readonly fEndColor: import("@angular/core").InputSignal<string>;
     abstract fOutputId: Signal<string>;
     abstract fInputId: Signal<string>;
     abstract fRadius: number;
@@ -29,11 +27,12 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements ISel
     abstract fType: EFConnectionType | string;
     readonly fDefs: Signal<ElementRef<SVGDefsElement>>;
     readonly fPath: Signal<import("./connection-path").FConnectionPathBase>;
-    readonly fGradient: Signal<import("./connection-gradient").FConnectionGradientBase>;
     readonly fDragHandleStart: Signal<import("./connection-drag-handles").FConnectionDragHandleBase | undefined>;
     readonly fDragHandleEnd: Signal<import("./connection-drag-handles").FConnectionDragHandleBase>;
     readonly fSelection: Signal<import("./connection-selection").FConnectionSelectionBase>;
     readonly fContents: Signal<readonly FConnectionContentBase[]>;
+    readonly fGradient: Signal<import("./connection-gradient").FConnectionGradientBase | undefined>;
+    private readonly _fGradientRenderer;
     readonly fWaypoints: Signal<import("./connection-waypoints").FConnectionWaypointsBase | undefined>;
     readonly fInputSide: Signal<EFConnectionConnectableSide>;
     private _sourceSide;
@@ -50,6 +49,10 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements ISel
     markChildrenAsSelected(): void;
     unmarkChildrenAsSelected(): void;
     redraw(): void;
+    getResolvedSides(): {
+        sourceSide: EFConnectableSide;
+        targetSide: EFConnectableSide;
+    };
     /**
      * Applies the resolved sides to the connection. Don't call this method directly; it's used internally.
      *
@@ -58,6 +61,6 @@ export declare abstract class FConnectionBase extends MIXIN_BASE implements ISel
      */
     _applyResolvedSidesToConnection(sourceSide: EFConnectableSide, targetSide: EFConnectableSide): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, { "fStartColor": { "alias": "fStartColor"; "required": false; "isSignal": true; }; "fEndColor": { "alias": "fEndColor"; "required": false; "isSignal": true; }; }, {}, ["fContents", "fWaypoints"], never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FConnectionBase, never, never, {}, {}, ["fContents", "fGradient", "fWaypoints"], never, false, never>;
 }
 export {};

package/f-connection-v2/models/f-connection-components-parent.d.ts

@@ -6,8 +6,6 @@ export declare abstract class FConnectionComponentsParent {
     abstract fId: Signal<string>;
     abstract fOutputId: Signal<string>;
     abstract fInputId: Signal<string>;
-    abstract fStartColor: Signal<string>;
-    abstract fEndColor: Signal<string>;
     abstract fBehavior: EFConnectionBehavior;
     abstract _applyResolvedSidesToConnection(sourceSide: EFConnectableSide, targetSide: EFConnectableSide): void;
     abstract fInputSide: Signal<EFConnectionConnectableSide>;

package/f-connection-v2/utils/create-gradient-dom-identifier.d.ts

@@ -1 +1 @@
-export declare function createGradientDomIdentifier(componentId: string, sourceId: string, targetId: string): string;
+export declare function createGradientDomIdentifier(componentId: string): string;

package/f-connection-v2/utils/create-gradient-dom-url.d.ts

@@ -1 +1 @@
-export declare function createGradientDomUrl(componentId: string, sourceId: string, targetId: string): string;
+export declare function createGradientDomUrl(componentId: string): string;

package/f-connection-worker/model/f-connection-worker.d.ts

@@ -2,6 +2,7 @@ import { TFConnectionWorkerPendingRequest } from './t-f-connection-worker-pendin
 import * as i0 from "@angular/core";
 export declare class FConnectionWorker {
     worker: Worker | null;
+    workerUrl: string | null;
     nextRequestId: number;
     isDisabled: boolean;
     readonly pending: Map<number, TFConnectionWorkerPendingRequest>;

package/f-connection-worker/worker/connection-worker-runtime.d.ts

@@ -0,0 +1,11 @@
+type TConnectionWorkerUrlApi = Pick<typeof URL, 'createObjectURL' | 'revokeObjectURL'>;
+type TConnectionWorkerRuntime = {
+    blobCtor: typeof Blob;
+    workerCtor: typeof Worker;
+    urlApi: TConnectionWorkerUrlApi;
+};
+export declare function isConnectionWorkerRuntimeSupported(windowRef: Window | null | undefined): boolean;
+export declare function resolveConnectionWorkerRuntime(windowRef: Window | null | undefined): TConnectionWorkerRuntime | null;
+export declare function createConnectionWorkerUrl(runtime: TConnectionWorkerRuntime): string;
+export declare function revokeConnectionWorkerUrl(workerUrl: string | null | undefined, urlApi?: Pick<typeof URL, 'revokeObjectURL'> | null): void;
+export {};

package/f-flow/f-flow.component.d.ts

@@ -7,6 +7,7 @@ export declare class FFlowComponent extends FFlowBase implements OnInit, AfterCo
     private readonly _destroyRef;
     private readonly _mediator;
     private readonly _browser;
+    private readonly _componentsStore;
     private readonly _cache;
     private readonly _injector;
     private readonly _worker;