@foblex/flow 17.7.1 → 17.8.1

package/f-connection/f-connection-content/polyline-content-engine/polyline-content-layout-engine.d.ts

@@ -0,0 +1,21 @@
+import { IPoint } from '@foblex/2d';
+import { IPolylineContent } from './i-polyline-content';
+import { PolylineContentPlace } from './polyline-content-place';
+/**
+ * Engine that orchestrates positioning and orientation of all
+ * connection contents along a computed path.
+ */
+export declare class ConnectionContentLayoutEngine {
+    private readonly _placement;
+    constructor(_placement?: PolylineContentPlace);
+    layout(line: {
+        point1: IPoint;
+        point2: IPoint;
+    }, builderResult: {
+        points?: IPoint[];
+        secondPoint: IPoint;
+        connectionCenter: IPoint;
+        penultimatePoint: IPoint;
+    }, contents: Iterable<IPolylineContent>): number;
+    private _createTransformString;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-content-place.d.ts

@@ -0,0 +1,18 @@
+import { IPolylineContent } from './i-polyline-content';
+import { IPoint } from '@foblex/2d';
+import { PolylineSampler } from './polyline-sampler';
+/**
+ * Encapsulates placement logic for a single content item along the path.
+ */
+export declare class PolylineContentPlace {
+    compute(sampler: PolylineSampler, content: IPolylineContent): {
+        position: IPoint;
+        rotationDeg: number;
+    };
+    private _clamp01;
+    private _applyEdgeGuard;
+    private _sizeAlongDirection;
+    private _normalize180;
+    private _keepUpright;
+    private _calculateContentRotation;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/i-sampler-result.d.ts

@@ -0,0 +1,11 @@
+import { ITangent } from './i-tangent';
+import { IPoint } from '@foblex/2d';
+/** Result of sampling the path. */
+export interface ISamplerResult {
+    /** Interpolated point on the polyline. */
+    point: IPoint;
+    /** Unit tangent (segment direction) at that point. */
+    tangent: ITangent;
+    /** Whether the result was clamped to the path edge (start or end). */
+    atEdge: boolean;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/i-tangent.d.ts

@@ -0,0 +1,4 @@
+import { IPoint } from '@foblex/2d';
+/** Unit tangent vector. */
+export interface ITangent extends IPoint {
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/index.d.ts

@@ -0,0 +1,4 @@
+export * from './i-sampler-result';
+export * from './i-tangent';
+export * from './polyline';
+export * from './polyline-sampler';

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/polyline-sampler.d.ts

@@ -0,0 +1,60 @@
+import { IPoint } from '@foblex/2d';
+import { ISamplerResult } from './i-sampler-result';
+/**
+ * Provides sampling (interpolation) along a {@link Polyline}.
+ * Separates traversal logic from pure geometry stored in {@link Polyline}.
+ */
+export declare class PolylineSampler {
+    private _polyline;
+    /**
+     * @param points Initial points to build the underlying polyline.
+     *               You can later call {@link updatePoints} to rebuild.
+     */
+    constructor(points?: IPoint[]);
+    /**
+     * Rebuild the underlying polyline from new points.
+     * @returns Total length of the rebuilt polyline.
+     */
+    updatePoints(points: IPoint[]): number;
+    /**
+     * Backward-compatible alias for older API naming.
+     * @returns Total length of the rebuilt polyline.
+     */
+    calculateTotalLength(points: IPoint[]): number;
+    /** Total length of the current polyline. */
+    get totalLength(): number;
+    /**
+     * Sample a point by normalized progress along the whole length.
+     *
+     * - `progress = 0` → start vertex
+     * - `progress = 1` → end vertex
+     *
+     * Uses a small edge threshold (0.5 units) to snap near-start/near-end queries to exact vertices,
+     * mirroring the behavior in the original implementation.
+     *
+     * @param progress Normalized value in [0..1]. Values are clamped to this range.
+     * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.
+     */
+    getPointAtProgress(progress: number): ISamplerResult;
+    /**
+     * Backward-compatible alias.
+     * Equivalent to {@link getPointAtProgress}.
+     */
+    getPointAtLength(progress: number): ISamplerResult;
+    /**
+     * Sample a point by absolute distance from the start (in the same units as your points).
+     * This is a convenience wrapper over {@link getPointAtProgress}.
+     *
+     * @param distance Distance from 0 to {@link totalLength}. Values outside are clamped.
+     * @returns Interpolated point, segment tangent, and whether it was clamped to an edge.
+     */
+    getPointAtDistance(distance: number): ISamplerResult;
+    /** Binary-search the first index where cumulativeLengths[index] >= target. */
+    private static _findRightIndex;
+    /** Linear interpolation between `a` and `b`. */
+    private static _lerp;
+    /** Clamp `value` into [min, max]. */
+    private static _clamp;
+    /** Safe ratio `num / den` with tiny-denominator guard. */
+    private static _safeRatio;
+}

package/f-connection/f-connection-content/polyline-content-engine/polyline-sampler/polyline.d.ts

@@ -0,0 +1,29 @@
+import { IPoint } from '@foblex/2d';
+import { ITangent } from './i-tangent';
+/**
+ * Immutable polyline geometry with precomputed cumulative lengths and segment tangents.
+ * Keep this class focused on geometry only; sampling/traversal lives in PolylineSampler.
+ */
+export declare class Polyline {
+    /** Cleaned points (with consecutive duplicates removed). */
+    readonly points: IPoint[];
+    /** Cumulative length from start to each vertex. Same length as `points`. */
+    readonly cumulativeLengths: number[];
+    /** Unit tangent per segment `i` for segment [i -> i+1]. Length = points.length - 1. */
+    readonly segmentTangents: ITangent[];
+    /** Total length of the polyline (>= 1 for the degenerate fallback). */
+    readonly totalLength: number;
+    /**
+     * Construct a polyline from raw points.
+     * Consecutive duplicate points are removed.
+     * If less than 2 points remain, it falls back to a unit horizontal segment [0,0] → [1,0].
+     */
+    constructor(points: IPoint[]);
+    /**
+     * Create a polyline by cloning points (defensive copy).
+     * @param points Raw input points; they will be copied and cleaned.
+     */
+    static from(points: IPoint[]): Polyline;
+    /** Remove consecutive duplicate points. */
+    private static _removeConsecutiveDuplicates;
+}

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

@@ -1,28 +1,26 @@
-import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, OnChanges, OnDestroy, OnInit } from '@angular/core';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
-import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
 export declare class FConnectionForCreateComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
     fId: import("@angular/core").WritableSignal<string>;
     fText: string;
     fTextStartOffset: string;
-    fOutputId: string;
-    fInputId: string;
+    fOutputId: import("@angular/core").WritableSignal<string>;
+    fInputId: import("@angular/core").WritableSignal<string>;
     fRadius: number;
     fOffset: number;
     fBehavior: EFConnectionBehavior;
     fType: EFConnectionType | string;
     get boundingElement(): HTMLElement | SVGElement;
     private readonly _mediator;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     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; }; }, {}, never, ["*", "[fConnectionCenter]"], 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; }; }, {}, never, ["*", "[fConnectionCenter]", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;
     static ngAcceptInputType_fBehavior: unknown;

package/f-connection/f-marker/f-marker-base.d.ts

@@ -1,6 +1,5 @@
 import { InjectionToken } from '@angular/core';
 import { IHasHostElement } from '../../i-has-host-element';
-import * as i0 from "@angular/core";
 export declare const F_MARKER: InjectionToken<unknown>;
 export declare abstract class FMarkerBase implements IHasHostElement {
     abstract hostElement: HTMLElement;
@@ -11,6 +10,4 @@ export declare abstract class FMarkerBase implements IHasHostElement {
     abstract type: string;
     abstract orient: 'auto' | 'auto-start-reverse' | string;
     abstract markerUnits: 'strokeWidth' | 'userSpaceOnUse';
-    static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-connection/f-marker/f-marker.directive.d.ts

@@ -1,9 +1,9 @@
-import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { OnDestroy, OnInit } from '@angular/core';
 import { FMarkerBase } from './f-marker-base';
 import * as i0 from "@angular/core";
 export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnDestroy {
-    private elementReference;
-    get hostElement(): HTMLElement;
+    readonly hostElement: any;
+    private readonly _mediator;
     width: number;
     height: number;
     refX: number;
@@ -11,10 +11,8 @@ export declare class FMarkerDirective extends FMarkerBase implements OnInit, OnD
     type: string;
     orient: 'auto' | 'auto-start-reverse' | 'calculated' | string;
     markerUnits: 'strokeWidth' | 'userSpaceOnUse';
-    private _fMediator;
-    constructor(elementReference: ElementRef<HTMLElement>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FMarkerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerDirective, "svg[fMarker]", never, { "hostElement": { "alias": "hostElement"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "refX": { "alias": "refX"; "required": false; }; "refY": { "alias": "refY"; "required": false; }; "type": { "alias": "type"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "markerUnits": { "alias": "markerUnits"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FMarkerDirective, "svg[fMarker]", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "refX": { "alias": "refX"; "required": false; }; "refY": { "alias": "refY"; "required": false; }; "type": { "alias": "type"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "markerUnits": { "alias": "markerUnits"; "required": false; }; }, {}, never, never, false, never>;
 }

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

@@ -1,7 +1,6 @@
-import { AfterViewInit, ElementRef, OnChanges, OnDestroy, OnInit } from "@angular/core";
+import { AfterViewInit, OnChanges, OnDestroy, OnInit } from '@angular/core';
 import { EFConnectionBehavior } from '../common';
 import { EFConnectionType } from '../common';
-import { FConnectionFactory } from '../f-connection-builder';
 import { FConnectionBase } from '../common/f-connection-base';
 import * as i0 from "@angular/core";
 export declare class FSnapConnectionComponent extends FConnectionBase implements AfterViewInit, OnInit, OnChanges, OnDestroy {
@@ -9,21 +8,20 @@ export declare class FSnapConnectionComponent extends FConnectionBase implements
     fText: string;
     fTextStartOffset: string;
     fSnapThreshold: number;
-    fOutputId: string;
-    fInputId: string;
+    fOutputId: import("@angular/core").WritableSignal<string>;
+    fInputId: import("@angular/core").WritableSignal<string>;
     fRadius: number;
     fOffset: number;
     fBehavior: EFConnectionBehavior;
     fType: EFConnectionType | string;
     get boundingElement(): HTMLElement | SVGElement;
     private readonly _mediator;
-    constructor(elementReference: ElementRef<HTMLElement>, fConnectionFactory: FConnectionFactory);
     ngOnInit(): void;
     ngAfterViewInit(): void;
     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; }; }, {}, never, ["*", "[fConnectionCenter]"], 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; }; }, {}, never, ["*", "[fConnectionCenter]", "[fConnectionContent]"], false, never>;
     static ngAcceptInputType_fSnapThreshold: unknown;
     static ngAcceptInputType_fRadius: unknown;
     static ngAcceptInputType_fOffset: unknown;

package/f-connection/index.d.ts

@@ -3,6 +3,7 @@ export * from './f-connection-for-create';
 export * from './f-connection';
 export * from './f-connection-builder';
 export * from './f-connection-center';
+export * from './f-connection-content';
 export * from './f-marker';
 export * from './f-snap-connection';
 export * from './providers';

package/f-connection/providers.d.ts

@@ -1,7 +1,7 @@
-import { FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective } from './common';
+import { FConnectionDragHandleEndComponent, FConnectionDragHandleStartComponent, FConnectionGradientComponent, FConnectionPathComponent, FConnectionSelectionComponent, FConnectionTextComponent, FConnectionTextPathDirective } from './common';
 import { FConnectionComponent } from './f-connection';
 import { FConnectionCenterDirective } from './f-connection-center';
 import { FConnectionForCreateComponent } from './f-connection-for-create';
 import { FMarkerDirective } from './f-marker';
 import { FSnapConnectionComponent } from './f-snap-connection';
-export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionSelectionComponent | typeof FConnectionCenterDirective | typeof FSnapConnectionComponent | typeof FConnectionComponent | typeof FConnectionForCreateComponent | typeof FConnectionPathComponent | typeof FConnectionGradientComponent | typeof FConnectionTextPathDirective | typeof FConnectionTextComponent | typeof FMarkerDirective)[];
+export declare const F_CONNECTION_PROVIDERS: (typeof FConnectionDragHandleStartComponent | typeof FConnectionDragHandleEndComponent | typeof FConnectionSelectionComponent | typeof FConnectionCenterDirective | typeof FConnectionTextComponent | typeof FConnectionTextPathDirective | typeof FConnectionGradientComponent | typeof FConnectionPathComponent | typeof FConnectionComponent | typeof FConnectionForCreateComponent | typeof FMarkerDirective | typeof FSnapConnectionComponent)[];

package/f-connectors/f-connector-base.d.ts

@@ -1,9 +1,10 @@
 import { EFConnectableSide } from './e-f-connectable-side';
 import { IHasHostElement } from '../i-has-host-element';
+import { Signal } from '@angular/core';
 export declare abstract class FConnectorBase implements IHasHostElement {
-    abstract fId: string;
+    abstract fId: Signal<string>;
     abstract fNodeId: string;
-    abstract disabled: boolean;
+    abstract disabled: Signal<boolean>;
     abstract hostElement: HTMLElement | SVGElement;
     abstract canBeConnected: boolean;
     private _isConnected;

package/f-connectors/f-node-input/f-node-input-base.d.ts

@@ -1,9 +1,10 @@
-import { InjectionToken } from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
 import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_INPUT: InjectionToken<FNodeInputBase>;
 export declare abstract class FNodeInputBase extends FConnectorBase {
-    abstract multiple: boolean;
+    abstract category: Signal<string | undefined>;
+    abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputBase, never, never, {}, {}, never, never, false, never>;

package/f-connectors/f-node-input/f-node-input.directive.d.ts

@@ -4,22 +4,21 @@ import { EFConnectableSide } from '../e-f-connectable-side';
 import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare class FNodeInputDirective extends FNodeInputBase implements OnInit, OnChanges, OnDestroy {
-    private _elementReference;
-    private _fMediator;
-    private _fNode;
-    fId: any;
-    multiple: boolean;
-    disabled: boolean;
+    readonly hostElement: any;
+    private readonly _mediator;
+    private readonly _node;
+    fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    category: import("@angular/core").InputSignalWithTransform<string | undefined, unknown>;
+    multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     userFConnectableSide: EFConnectableSide;
     get fNodeId(): string;
-    get hostElement(): HTMLElement | SVGElement;
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     setConnected(toConnector: FConnectorBase): void;
     resetConnected(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeInputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "fId": { "alias": "fInputId"; "required": false; }; "multiple": { "alias": "fInputMultiple"; "required": false; }; "disabled": { "alias": "fInputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeInputDirective, "[fNodeInput]", ["fNodeInput"], { "fId": { "alias": "fInputId"; "required": false; "isSignal": true; }; "category": { "alias": "fInputCategory"; "required": false; "isSignal": true; }; "multiple": { "alias": "fInputMultiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "fInputDisabled"; "required": false; "isSignal": true; }; "userFConnectableSide": { "alias": "fInputConnectableSide"; "required": false; }; }, {}, never, never, false, never>;
     static ngAcceptInputType_userFConnectableSide: unknown;
 }

package/f-connectors/f-node-outlet/f-node-outlet-base.d.ts

@@ -1,12 +1,12 @@
 import { InjectionToken } from '@angular/core';
 import { FConnectorBase } from '../f-connector-base';
+import { FSourceConnectorBase } from '../f-source-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTLET: InjectionToken<FNodeOutletBase>;
-export declare abstract class FNodeOutletBase extends FConnectorBase {
+export declare abstract class FNodeOutletBase extends FSourceConnectorBase {
     abstract isConnectionFromOutlet: boolean;
-    private outputs;
+    private _outputs;
     get canBeConnected(): boolean;
-    abstract canBeConnectedInputs: string[];
     setOutputs(outputs: FConnectorBase[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletBase, never, never, {}, {}, never, never, false, never>;

package/f-connectors/f-node-outlet/f-node-outlet.directive.d.ts

@@ -3,20 +3,18 @@ import { FNodeOutletBase } from './f-node-outlet-base';
 import { EFConnectableSide } from '../e-f-connectable-side';
 import * as i0 from "@angular/core";
 export declare class FNodeOutletDirective extends FNodeOutletBase implements OnInit, OnDestroy {
-    private _elementReference;
-    private _fMediator;
-    private _fNode;
-    fId: string;
-    disabled: boolean;
+    readonly hostElement: any;
+    private readonly _mediator;
+    private readonly _node;
+    fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     fConnectableSide: EFConnectableSide;
     userFConnectableSide: EFConnectableSide;
     isConnectionFromOutlet: boolean;
     canBeConnectedInputs: string[];
     get fNodeId(): string;
-    get hostElement(): HTMLElement | SVGElement;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutletDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "fId": { "alias": "fOutletId"; "required": false; }; "disabled": { "alias": "fOutletDisabled"; "required": false; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutletDirective, "[fNodeOutlet]", ["fNodeOutlet"], { "fId": { "alias": "fOutletId"; "required": false; "isSignal": true; }; "disabled": { "alias": "fOutletDisabled"; "required": false; "isSignal": true; }; "isConnectionFromOutlet": { "alias": "isConnectionFromOutlet"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
 }

package/f-connectors/f-node-output/f-node-output-base.d.ts

@@ -1,11 +1,10 @@
-import { InjectionToken } from '@angular/core';
-import { FConnectorBase } from '../f-connector-base';
+import { InjectionToken, Signal } from '@angular/core';
+import { FSourceConnectorBase } from '../f-source-connector-base';
 import * as i0 from "@angular/core";
 export declare const F_NODE_OUTPUT: InjectionToken<FNodeOutputBase>;
-export declare abstract class FNodeOutputBase extends FConnectorBase {
-    abstract multiple: boolean;
+export declare abstract class FNodeOutputBase extends FSourceConnectorBase {
+    abstract multiple: Signal<boolean>;
     get canBeConnected(): boolean;
-    abstract canBeConnectedInputs: string[];
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputBase, never, never, {}, {}, never, never, false, never>;
 }

package/f-connectors/f-node-output/f-node-output.directive.d.ts

@@ -4,24 +4,22 @@ import { EFConnectableSide } from '../e-f-connectable-side';
 import { FConnectorBase } from '../f-connector-base';
 import * as i0 from "@angular/core";
 export declare class FNodeOutputDirective extends FNodeOutputBase implements OnInit, OnChanges, OnDestroy {
-    private _elementReference;
-    private _fMediator;
-    private _fNode;
-    fId: string;
-    multiple: boolean;
-    disabled: boolean;
+    readonly hostElement: any;
+    private readonly _mediator;
+    private readonly _node;
+    fId: import("@angular/core").InputSignalWithTransform<string, unknown>;
+    multiple: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     userFConnectableSide: EFConnectableSide;
     isSelfConnectable: boolean;
     canBeConnectedInputs: string[];
     get fNodeId(): string;
-    get hostElement(): HTMLElement | SVGElement;
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
     setConnected(toConnector: FConnectorBase): void;
     resetConnected(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FNodeOutputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "fId": { "alias": "fOutputId"; "required": false; }; "multiple": { "alias": "fOutputMultiple"; "required": false; }; "disabled": { "alias": "fOutputDisabled"; "required": false; }; "userFConnectableSide": { "alias": "fOutputConnectableSide"; "required": false; }; "isSelfConnectable": { "alias": "isSelfConnectable"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
-    static ngAcceptInputType_disabled: unknown;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FNodeOutputDirective, "[fNodeOutput]", ["fNodeOutput"], { "fId": { "alias": "fOutputId"; "required": false; "isSignal": true; }; "multiple": { "alias": "fOutputMultiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "fOutputDisabled"; "required": false; "isSignal": true; }; "userFConnectableSide": { "alias": "fOutputConnectableSide"; "required": false; }; "isSelfConnectable": { "alias": "isSelfConnectable"; "required": false; }; "canBeConnectedInputs": { "alias": "fCanBeConnectedInputs"; "required": false; }; }, {}, never, never, false, never>;
     static ngAcceptInputType_userFConnectableSide: unknown;
 }

package/f-connectors/f-source-connector-base.d.ts

@@ -0,0 +1,7 @@
+import { FConnectorBase } from './f-connector-base';
+import { FNodeInputBase } from './f-node-input';
+export declare abstract class FSourceConnectorBase extends FConnectorBase {
+    abstract canBeConnectedInputs: string[];
+    get hasConnectionLimits(): boolean;
+    canConnectTo(targetConnector: FNodeInputBase): boolean;
+}

package/f-connectors/index.d.ts

@@ -2,5 +2,6 @@ export * from './f-node-input';
 export * from './f-node-outlet';
 export * from './f-node-output';
 export * from './f-connector-base';
+export * from './f-source-connector-base';
 export * from './e-f-connectable-side';
 export * from './providers';

package/f-draggable/domain/is-connection-under-node/is-connection-under-node.execution.d.ts

@@ -2,7 +2,7 @@ import { IExecution } from '@foblex/mediator';
 import { IsConnectionUnderNodeRequest } from './is-connection-under-node.request';
 import * as i0 from "@angular/core";
 export declare class IsConnectionUnderNodeExecution implements IExecution<IsConnectionUnderNodeRequest, void> {
-    private readonly _fMediator;
+    private readonly _mediator;
     private readonly _store;
     handle(request: IsConnectionUnderNodeRequest): void;
     private _getOutputConnectors;

package/f-draggable/domain/providers.d.ts

@@ -1,4 +1,4 @@
 import { IsArrayHasParentNodeExecution } from './is-array-has-parent-node';
 import { GetNormalizedParentNodeRectExecution } from './get-normalized-parent-node-rect';
 import { IsConnectionUnderNodeExecution } from './is-connection-under-node';
-export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof GetNormalizedParentNodeRectExecution | typeof IsConnectionUnderNodeExecution | typeof IsArrayHasParentNodeExecution)[];
+export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof IsConnectionUnderNodeExecution | typeof GetNormalizedParentNodeRectExecution | typeof IsArrayHasParentNodeExecution)[];

package/f-draggable/f-canvas/move-finalize/f-canvas-move-finalize.execution.d.ts

@@ -2,8 +2,8 @@ import { FCanvasMoveFinalizeRequest } from './f-canvas-move-finalize.request';
 import { IExecution } from '@foblex/mediator';
 import * as i0 from "@angular/core";
 export declare class FCanvasMoveFinalizeExecution implements IExecution<FCanvasMoveFinalizeRequest, void> {
-    private _dragContext;
-    handle(request: FCanvasMoveFinalizeRequest): void;
+    private readonly _dragContext;
+    handle(_request: FCanvasMoveFinalizeRequest): void;
     private _isValid;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCanvasMoveFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FCanvasMoveFinalizeExecution>;

package/f-draggable/f-connection/f-create-connection/create-finalize/f-create-connection-finalize.execution.d.ts

@@ -2,17 +2,17 @@ import { IHandler } from '@foblex/mediator';
 import { FCreateConnectionFinalizeRequest } from './f-create-connection-finalize.request';
 import * as i0 from "@angular/core";
 export declare class FCreateConnectionFinalizeExecution implements IHandler<FCreateConnectionFinalizeRequest, void> {
-    private _fResult;
-    private _fMediator;
-    private _store;
-    private _dragContext;
-    private get _fDragHandler();
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragContext;
+    private get _dragHandler();
     handle(request: FCreateConnectionFinalizeRequest): void;
     private _isValid;
-    private getTargetOutput;
-    private getOutput;
-    private getOutlet;
-    private emitEvent;
+    private _getTargetOutput;
+    private _getOutput;
+    private _getOutlet;
+    private _emitEvent;
     private _getInputUnderPointer;
     static ɵfac: i0.ɵɵFactoryDeclaration<FCreateConnectionFinalizeExecution, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FCreateConnectionFinalizeExecution>;

package/f-draggable/f-connection/f-create-connection/f-create-connection.drag-handler.d.ts

@@ -5,13 +5,13 @@ import { Injector } from '@angular/core';
 export declare class FCreateConnectionDragHandler implements IFDragHandler {
     private _fOutputOrOutlet;
     fEventType: string;
-    fData: any;
-    private readonly _fResult;
-    private readonly _fMediator;
+    fData: unknown;
+    private readonly _result;
+    private readonly _mediator;
     private readonly _store;
     private readonly _toConnectorRect;
-    private get _fConnection();
-    private get _fSnapConnection();
+    private get _connection();
+    private get _snapConnection();
     private _fOutputWithRect;
     private _canBeConnectedInputs;
     constructor(_injector: Injector, _fOutputOrOutlet: FNodeOutputBase | FNodeOutletBase, _onPointerDownPosition: IPoint);

package/f-draggable/f-connection/f-reassign-connection/f-reassign-connection.drag-handler.d.ts

@@ -6,11 +6,11 @@ export declare class FReassignConnectionDragHandler implements IFDragHandler {
     private _connection;
     private _isTargetDragHandle;
     fEventType: string;
-    fData: any;
-    private readonly _fResult;
-    private readonly _fMediator;
+    fData: unknown;
+    private readonly _result;
+    private readonly _mediator;
     private readonly _store;
-    private get _fSnapConnection();
+    private get _snapConnection();
     private get _sourceConnector();
     private get _targetConnector();
     private get _sourceConnectorAndRect();

package/f-draggable/f-connection/f-reassign-connection/f-reassign-source.drag-handler.d.ts

@@ -1,8 +1,8 @@
-import { FMediator } from "@foblex/mediator";
-import { IConnectorAndRect } from "../../../domain";
-import { FConnectionBase, FSnapConnectionComponent } from "../../../f-connection";
-import { IPoint } from "@foblex/2d";
-import { IFReassignHandler } from "./i-f-reassign-handler";
+import { FMediator } from '@foblex/mediator';
+import { IConnectorAndRect } from '../../../domain';
+import { FConnectionBase, FSnapConnectionComponent } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IFReassignHandler } from './i-f-reassign-handler';
 export declare class FReassignSourceDragHandler implements IFReassignHandler {
     private readonly _mediator;
     private readonly _connection;

package/f-draggable/f-connection/f-reassign-connection/f-reassign-target.drag-handler.d.ts

@@ -1,8 +1,8 @@
-import { FMediator } from "@foblex/mediator";
-import { IConnectorAndRect } from "../../../domain";
-import { FConnectionBase, FSnapConnectionComponent } from "../../../f-connection";
-import { IPoint } from "@foblex/2d";
-import { IFReassignHandler } from "./i-f-reassign-handler";
+import { FMediator } from '@foblex/mediator';
+import { IConnectorAndRect } from '../../../domain';
+import { FConnectionBase, FSnapConnectionComponent } from '../../../f-connection';
+import { IPoint } from '@foblex/2d';
+import { IFReassignHandler } from './i-f-reassign-handler';
 export declare class FReassignTargetDragHandler implements IFReassignHandler {
     private readonly _mediator;
     private readonly _connection;

package/f-draggable/f-connection/providers.d.ts

@@ -1,3 +1,3 @@
 import { FCreateConnectionDragHandlerPreparationExecution, FCreateConnectionFinalizeExecution, FCreateConnectionFromOutletPreparationExecution, FCreateConnectionFromOutputPreparationExecution, FCreateConnectionPreparationExecution, GetFirstConnectableOutputExecution } from './f-create-connection';
 import { FReassignConnectionFinalizeExecution, FReassignConnectionPreparationExecution } from './f-reassign-connection';
-export declare const CONNECTIONS_PROVIDERS: (typeof FCreateConnectionFinalizeExecution | typeof FCreateConnectionDragHandlerPreparationExecution | typeof FCreateConnectionFromOutletPreparationExecution | typeof GetFirstConnectableOutputExecution | typeof FCreateConnectionFromOutputPreparationExecution | typeof FCreateConnectionPreparationExecution | typeof FReassignConnectionFinalizeExecution | typeof FReassignConnectionPreparationExecution)[];
+export declare const CONNECTIONS_PROVIDERS: (typeof FCreateConnectionPreparationExecution | typeof FReassignConnectionFinalizeExecution | typeof FReassignConnectionPreparationExecution | typeof FCreateConnectionFromOutputPreparationExecution | typeof FCreateConnectionFromOutletPreparationExecution | typeof FCreateConnectionFinalizeExecution | typeof FCreateConnectionDragHandlerPreparationExecution | typeof GetFirstConnectableOutputExecution)[];