@foblex/flow 18.1.2 → 18.2.0

package/f-connection-worker/features/calculate-connection-worker-payload-item/calculate-connection-worker-payload-item-request.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection-v2';
+export declare class CalculateConnectionWorkerPayloadItemRequest {
+    readonly connection: FConnectionBase;
+    readonly cache: Map<string, IRoundedRect>;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase, cache: Map<string, IRoundedRect>);
+}

package/f-connection-worker/features/calculate-connection-worker-payload-item/calculate-connection-worker-payload-item.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { IFConnectionWorkerRequestItem } from '../../model';
+import { CalculateConnectionWorkerPayloadItemRequest } from './calculate-connection-worker-payload-item-request';
+import * as i0 from "@angular/core";
+export declare class CalculateConnectionWorkerPayloadItem implements IExecution<CalculateConnectionWorkerPayloadItemRequest, IFConnectionWorkerRequestItem | null> {
+    private readonly _mediator;
+    handle({ connection, cache, }: CalculateConnectionWorkerPayloadItemRequest): IFConnectionWorkerRequestItem | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectionWorkerPayloadItem, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectionWorkerPayloadItem>;
+}

package/f-connection-worker/features/calculate-connection-worker-payload-item/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-connection-worker-payload-item';
+export * from './calculate-connection-worker-payload-item-request';

package/f-connection-worker/features/calculate-connections-using-connection-worker/calculate-connections-using-connection-worker-request.d.ts

@@ -0,0 +1,8 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection-v2';
+export declare class CalculateConnectionsUsingConnectionWorkerRequest {
+    readonly connections: readonly FConnectionBase[];
+    readonly cache: Map<string, IRoundedRect>;
+    static readonly fToken: unique symbol;
+    constructor(connections: readonly FConnectionBase[], cache: Map<string, IRoundedRect>);
+}

package/f-connection-worker/features/calculate-connections-using-connection-worker/calculate-connections-using-connection-worker.d.ts

@@ -0,0 +1,12 @@
+import { IExecution } from '@foblex/mediator';
+import { CalculateConnectionsUsingConnectionWorkerRequest } from './calculate-connections-using-connection-worker-request';
+import { IFConnectionWorkerResultItem } from '../../model';
+import * as i0 from "@angular/core";
+export declare class CalculateConnectionsUsingConnectionWorker implements IExecution<CalculateConnectionsUsingConnectionWorkerRequest, Promise<readonly IFConnectionWorkerResultItem[] | null>> {
+    private readonly _mediator;
+    handle({ connections, cache, }: CalculateConnectionsUsingConnectionWorkerRequest): Promise<readonly IFConnectionWorkerResultItem[] | null>;
+    private _buildWorkerPayload;
+    private _calculateWorkerPayloadItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalculateConnectionsUsingConnectionWorker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalculateConnectionsUsingConnectionWorker>;
+}

package/f-connection-worker/features/calculate-connections-using-connection-worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './calculate-connections-using-connection-worker';
+export * from './calculate-connections-using-connection-worker-request';

package/f-connection-worker/features/connection-worker-run/connection-worker-run-request.d.ts

@@ -0,0 +1,6 @@
+import { IFConnectionWorkerRequestItem } from '../../model';
+export declare class ConnectionWorkerRunRequest {
+    readonly payload: IFConnectionWorkerRequestItem[];
+    static readonly fToken: unique symbol;
+    constructor(payload: IFConnectionWorkerRequestItem[]);
+}

package/f-connection-worker/features/connection-worker-run/connection-worker-run.d.ts

@@ -0,0 +1,12 @@
+import { IExecution } from '@foblex/mediator';
+import { IFConnectionWorkerResultItem } from '../../model';
+import { ConnectionWorkerRunRequest } from './connection-worker-run-request';
+import * as i0 from "@angular/core";
+export declare class ConnectionWorkerRun implements IExecution<ConnectionWorkerRunRequest, Promise<IFConnectionWorkerResultItem[]>> {
+    private readonly _state;
+    private readonly _mediator;
+    handle({ payload }: ConnectionWorkerRunRequest): Promise<IFConnectionWorkerResultItem[]>;
+    private _interruptPendingRequests;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionWorkerRun, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionWorkerRun>;
+}

package/f-connection-worker/features/connection-worker-run/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connection-worker-run';
+export * from './connection-worker-run-request';

package/f-connection-worker/features/disable-connection-worker/disable-connection-worker-request.d.ts

@@ -0,0 +1,5 @@
+export declare class DisableConnectionWorkerRequest {
+    readonly error: Error;
+    static readonly fToken: unique symbol;
+    constructor(error: Error);
+}

package/f-connection-worker/features/disable-connection-worker/disable-connection-worker.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { DisableConnectionWorkerRequest } from './disable-connection-worker-request';
+import * as i0 from "@angular/core";
+export declare class DisableConnectionWorker implements IExecution<DisableConnectionWorkerRequest, void> {
+    private readonly _state;
+    private readonly _mediator;
+    handle({ error }: DisableConnectionWorkerRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisableConnectionWorker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DisableConnectionWorker>;
+}

package/f-connection-worker/features/disable-connection-worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './disable-connection-worker';
+export * from './disable-connection-worker-request';

package/f-connection-worker/features/ensure-connection-worker/ensure-connection-worker-request.d.ts

@@ -0,0 +1,3 @@
+export declare class EnsureConnectionWorkerRequest {
+    static readonly fToken: unique symbol;
+}

package/f-connection-worker/features/ensure-connection-worker/ensure-connection-worker.d.ts

@@ -0,0 +1,13 @@
+import { IExecution } from '@foblex/mediator';
+import { EnsureConnectionWorkerRequest } from './ensure-connection-worker-request';
+import * as i0 from "@angular/core";
+export declare class EnsureConnectionWorker implements IExecution<EnsureConnectionWorkerRequest, Worker | null> {
+    private readonly _browser;
+    private readonly _state;
+    private readonly _mediator;
+    handle(_: EnsureConnectionWorkerRequest): Worker | null;
+    private _disableWorker;
+    private _resetWorkerAfterRuntimeError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnsureConnectionWorker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnsureConnectionWorker>;
+}

package/f-connection-worker/features/ensure-connection-worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ensure-connection-worker';
+export * from './ensure-connection-worker-request';

package/f-connection-worker/features/handle-connection-worker-message/handle-connection-worker-message-request.d.ts

@@ -0,0 +1,6 @@
+import { IFConnectionWorkerResponse } from '../../model';
+export declare class HandleConnectionWorkerMessageRequest {
+    readonly message?: IFConnectionWorkerResponse | undefined;
+    static readonly fToken: unique symbol;
+    constructor(message?: IFConnectionWorkerResponse | undefined);
+}

package/f-connection-worker/features/handle-connection-worker-message/handle-connection-worker-message.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { HandleConnectionWorkerMessageRequest } from './handle-connection-worker-message-request';
+import * as i0 from "@angular/core";
+export declare class HandleConnectionWorkerMessage implements IExecution<HandleConnectionWorkerMessageRequest, void> {
+    private readonly _state;
+    handle({ message }: HandleConnectionWorkerMessageRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HandleConnectionWorkerMessage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HandleConnectionWorkerMessage>;
+}

package/f-connection-worker/features/handle-connection-worker-message/index.d.ts

@@ -0,0 +1,2 @@
+export * from './handle-connection-worker-message';
+export * from './handle-connection-worker-message-request';

package/f-connection-worker/features/index.d.ts

@@ -0,0 +1,12 @@
+export * from './connection-worker-run';
+export * from './calculate-connections-using-connection-worker';
+export * from './calculate-connection-worker-payload-item';
+export * from './resolve-connection-worker-connectors';
+export * from './resolve-connection-worker-context';
+export * from './disable-connection-worker';
+export * from './reset-connection-worker-runtime';
+export * from './ensure-connection-worker';
+export * from './handle-connection-worker-message';
+export * from './calculate-connection-worker-connector-rect';
+export * from './is-connection-worker-enabled';
+export * from './should-use-connection-worker';

package/f-connection-worker/features/is-connection-worker-enabled/index.d.ts

@@ -0,0 +1,2 @@
+export * from './is-connection-worker-enabled';
+export * from './is-connection-worker-enabled-request';

package/f-connection-worker/features/is-connection-worker-enabled/is-connection-worker-enabled-request.d.ts

@@ -0,0 +1,3 @@
+export declare class IsConnectionWorkerEnabledRequest {
+    static readonly fToken: unique symbol;
+}

package/f-connection-worker/features/is-connection-worker-enabled/is-connection-worker-enabled.d.ts

@@ -0,0 +1,11 @@
+import { IExecution } from '@foblex/mediator';
+import { IsConnectionWorkerEnabledRequest } from './is-connection-worker-enabled-request';
+import * as i0 from "@angular/core";
+export declare class IsConnectionWorkerEnabled implements IExecution<IsConnectionWorkerEnabledRequest, boolean> {
+    private readonly _browser;
+    private readonly _state;
+    handle(_: IsConnectionWorkerEnabledRequest): boolean;
+    private _isWorkerAvailable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsConnectionWorkerEnabled, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IsConnectionWorkerEnabled>;
+}

package/f-connection-worker/features/reset-connection-worker-runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reset-connection-worker-runtime';
+export * from './reset-connection-worker-runtime-request';

package/f-connection-worker/features/reset-connection-worker-runtime/reset-connection-worker-runtime-request.d.ts

@@ -0,0 +1,5 @@
+export declare class ResetConnectionWorkerRuntimeRequest {
+    readonly error: Error;
+    static readonly fToken: unique symbol;
+    constructor(error: Error);
+}

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

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { ResetConnectionWorkerRuntimeRequest } from './reset-connection-worker-runtime-request';
+import * as i0 from "@angular/core";
+export declare class ResetConnectionWorkerRuntime implements IExecution<ResetConnectionWorkerRuntimeRequest, void> {
+    private readonly _state;
+    handle({ error }: ResetConnectionWorkerRuntimeRequest): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResetConnectionWorkerRuntime, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResetConnectionWorkerRuntime>;
+}

package/f-connection-worker/features/resolve-connection-worker-connectors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolve-connection-worker-connectors';
+export * from './resolve-connection-worker-connectors-request';

package/f-connection-worker/features/resolve-connection-worker-connectors/resolve-connection-worker-connectors-request.d.ts

@@ -0,0 +1,11 @@
+import { FConnectorBase } from '../../../f-connectors';
+import { FConnectionBase } from '../../../f-connection-v2';
+export interface IFConnectionWorkerConnectors {
+    source: FConnectorBase;
+    target: FConnectorBase;
+}
+export declare class ResolveConnectionWorkerConnectorsRequest {
+    readonly connection: FConnectionBase;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase);
+}

package/f-connection-worker/features/resolve-connection-worker-connectors/resolve-connection-worker-connectors.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { IFConnectionWorkerConnectors, ResolveConnectionWorkerConnectorsRequest } from './resolve-connection-worker-connectors-request';
+import * as i0 from "@angular/core";
+export declare class ResolveConnectionWorkerConnectors implements IExecution<ResolveConnectionWorkerConnectorsRequest, IFConnectionWorkerConnectors | null> {
+    private readonly _store;
+    handle({ connection, }: ResolveConnectionWorkerConnectorsRequest): IFConnectionWorkerConnectors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectionWorkerConnectors, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectionWorkerConnectors>;
+}

package/f-connection-worker/features/resolve-connection-worker-context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './resolve-connection-worker-context';
+export * from './resolve-connection-worker-context-request';

package/f-connection-worker/features/resolve-connection-worker-context/resolve-connection-worker-context-request.d.ts

@@ -0,0 +1,13 @@
+import { IRoundedRect } from '@foblex/2d';
+import { FConnectionBase } from '../../../f-connection-v2';
+import { IFConnectionWorkerConnectors } from '../resolve-connection-worker-connectors';
+export interface IFConnectionWorkerContext extends IFConnectionWorkerConnectors {
+    sourceRect: IRoundedRect;
+    targetRect: IRoundedRect;
+}
+export declare class ResolveConnectionWorkerContextRequest {
+    readonly connection: FConnectionBase;
+    readonly cache: Map<string, IRoundedRect>;
+    static readonly fToken: unique symbol;
+    constructor(connection: FConnectionBase, cache: Map<string, IRoundedRect>);
+}

package/f-connection-worker/features/resolve-connection-worker-context/resolve-connection-worker-context.d.ts

@@ -0,0 +1,10 @@
+import { IExecution } from '@foblex/mediator';
+import { IFConnectionWorkerContext, ResolveConnectionWorkerContextRequest } from './resolve-connection-worker-context-request';
+import * as i0 from "@angular/core";
+export declare class ResolveConnectionWorkerContext implements IExecution<ResolveConnectionWorkerContextRequest, IFConnectionWorkerContext | null> {
+    private readonly _mediator;
+    handle({ connection, cache, }: ResolveConnectionWorkerContextRequest): IFConnectionWorkerContext | null;
+    private _calculateConnectorRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResolveConnectionWorkerContext, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResolveConnectionWorkerContext>;
+}

package/f-connection-worker/features/should-use-connection-worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './should-use-connection-worker';
+export * from './should-use-connection-worker-request';

package/f-connection-worker/features/should-use-connection-worker/should-use-connection-worker-request.d.ts

@@ -0,0 +1,5 @@
+export declare class ShouldUseConnectionWorkerRequest {
+    readonly connectionCount: number;
+    static readonly fToken: unique symbol;
+    constructor(connectionCount: number);
+}

package/f-connection-worker/features/should-use-connection-worker/should-use-connection-worker.d.ts

@@ -0,0 +1,9 @@
+import { IExecution } from '@foblex/mediator';
+import { ShouldUseConnectionWorkerRequest } from './should-use-connection-worker-request';
+import * as i0 from "@angular/core";
+export declare class ShouldUseConnectionWorker implements IExecution<ShouldUseConnectionWorkerRequest, boolean> {
+    private readonly _mediator;
+    handle({ connectionCount }: ShouldUseConnectionWorkerRequest): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShouldUseConnectionWorker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShouldUseConnectionWorker>;
+}

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

@@ -0,0 +1,3 @@
+export * from './features';
+export * from './model';
+export * from './providers';

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

@@ -0,0 +1,12 @@
+import { TFConnectionWorkerPendingRequest } from './t-f-connection-worker-pending-request';
+import * as i0 from "@angular/core";
+export declare class FConnectionWorker {
+    worker: Worker | null;
+    nextRequestId: number;
+    isDisabled: boolean;
+    readonly pending: Map<number, TFConnectionWorkerPendingRequest>;
+    resetRuntime(error: Error): void;
+    dispose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FConnectionWorker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FConnectionWorker>;
+}

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

@@ -0,0 +1,6 @@
+export interface IFConnectionWorkerRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/f-connection-worker/model/i-f-connection-worker-request-item.d.ts

@@ -0,0 +1,11 @@
+import { IFConnectionWorkerRect } from './i-f-connection-worker-rect';
+export interface IFConnectionWorkerRequestItem {
+    originalIndex?: number;
+    behavior: string;
+    outputSide: string;
+    inputSide: string;
+    sourceConnectableSide: string;
+    targetConnectableSide: string;
+    sourceRect: IFConnectionWorkerRect;
+    targetRect: IFConnectionWorkerRect;
+}

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

@@ -0,0 +1,6 @@
+import { IFConnectionWorkerResultItem } from './i-f-connection-worker-result-item';
+export interface IFConnectionWorkerResponse {
+    requestId: number;
+    results?: IFConnectionWorkerResultItem[];
+    error?: string;
+}

package/f-connection-worker/model/i-f-connection-worker-result-item.d.ts

@@ -0,0 +1,8 @@
+import { ILine } from '@foblex/2d';
+export interface IFConnectionWorkerResultItem {
+    originalIndex?: number;
+    supported: boolean;
+    sourceSide?: string;
+    targetSide?: string;
+    line?: ILine;
+}

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

@@ -0,0 +1,6 @@
+export * from './f-connection-worker';
+export * from './i-f-connection-worker-rect';
+export * from './i-f-connection-worker-request-item';
+export * from './i-f-connection-worker-response';
+export * from './i-f-connection-worker-result-item';
+export * from './t-f-connection-worker-pending-request';

package/f-connection-worker/model/t-f-connection-worker-pending-request.d.ts

@@ -0,0 +1,5 @@
+import { IFConnectionWorkerResultItem } from './i-f-connection-worker-result-item';
+export type TFConnectionWorkerPendingRequest = {
+    resolve: (value: IFConnectionWorkerResultItem[]) => void;
+    reject: (error: Error) => void;
+};

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

@@ -0,0 +1,3 @@
+import { FConnectionWorker } from './model';
+import { CalculateConnectionWorkerConnectorRect, CalculateConnectionWorkerPayloadItem, CalculateConnectionsUsingConnectionWorker, ConnectionWorkerRun, DisableConnectionWorker, EnsureConnectionWorker, HandleConnectionWorkerMessage, IsConnectionWorkerEnabled, ResetConnectionWorkerRuntime, ResolveConnectionWorkerConnectors, ResolveConnectionWorkerContext, ShouldUseConnectionWorker } from './features';
+export declare const F_CONNECTION_WORKER_FEATURES: (typeof FConnectionWorker | typeof ResetConnectionWorkerRuntime | typeof DisableConnectionWorker | typeof HandleConnectionWorkerMessage | typeof EnsureConnectionWorker | typeof IsConnectionWorkerEnabled | typeof ConnectionWorkerRun | typeof ResolveConnectionWorkerConnectors | typeof CalculateConnectionWorkerConnectorRect | typeof ResolveConnectionWorkerContext | typeof CalculateConnectionWorkerPayloadItem | typeof CalculateConnectionsUsingConnectionWorker | typeof ShouldUseConnectionWorker)[];

package/f-draggable/domain/get-normalized-parent-node-rect/get-normalized-parent-node-rect.d.ts

@@ -0,0 +1,15 @@
+import { GetNormalizedParentNodeRectRequest } from './get-normalized-parent-node-rect-request';
+import { IRect } from '@foblex/2d';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class GetNormalizedParentNodeRect implements IExecution<GetNormalizedParentNodeRectRequest, IRect> {
+    private readonly _store;
+    private readonly _mediator;
+    handle({ nodeOrGroup }: GetNormalizedParentNodeRectRequest): IRect;
+    private _getNode;
+    private _getParentRect;
+    private _getNodeRect;
+    private _getNodePadding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetNormalizedParentNodeRect, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GetNormalizedParentNodeRect>;
+}

package/f-draggable/domain/get-normalized-parent-node-rect/index.d.ts

@@ -1,2 +1,2 @@
-export * from './get-normalized-parent-node-rect.execution';
-export * from './get-normalized-parent-node-rect.request';
+export * from './get-normalized-parent-node-rect';
+export * from './get-normalized-parent-node-rect-request';

package/f-draggable/domain/is-array-has-parent-node/index.d.ts

@@ -1,2 +1,2 @@
-export * from './is-array-has-parent-node.execution';
-export * from './is-array-has-parent-node.request';
+export * from './is-array-has-parent-node';
+export * from './is-array-has-parent-node-request';

package/f-draggable/domain/is-array-has-parent-node/is-array-has-parent-node.d.ts

@@ -0,0 +1,10 @@
+import { IsArrayHasParentNodeRequest } from './is-array-has-parent-node-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class IsArrayHasParentNode implements IExecution<IsArrayHasParentNodeRequest, boolean> {
+    handle(request: IsArrayHasParentNodeRequest): boolean;
+    private _getParentNodeIds;
+    private _isParentNodeInArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsArrayHasParentNode, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IsArrayHasParentNode>;
+}

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

@@ -1,7 +1,7 @@
-import { IsArrayHasParentNodeExecution } from './is-array-has-parent-node';
-import { GetNormalizedParentNodeRectExecution } from './get-normalized-parent-node-rect';
+import { IsArrayHasParentNode } from './is-array-has-parent-node';
+import { GetNormalizedParentNodeRect } from './get-normalized-parent-node-rect';
 import { DetectConnectionsUnderDragNode } from './detect-connections-under-drag-node';
 import { EmitStartDragSequenceEvent } from './emit-start-drag-sequence-event';
 import { EmitEndDragSequenceEvent } from './emit-end-drag-sequence-event';
 import { EmitSelectionChangeEvent } from './emit-selection-change-event';
-export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof EmitEndDragSequenceEvent | typeof EmitStartDragSequenceEvent | typeof EmitSelectionChangeEvent | typeof GetNormalizedParentNodeRectExecution | typeof IsArrayHasParentNodeExecution | typeof DetectConnectionsUnderDragNode)[];
+export declare const DRAG_AND_DROP_COMMON_PROVIDERS: (typeof EmitEndDragSequenceEvent | typeof EmitStartDragSequenceEvent | typeof EmitSelectionChangeEvent | typeof GetNormalizedParentNodeRect | typeof IsArrayHasParentNode | typeof DetectConnectionsUnderDragNode)[];

package/f-draggable/drag-external-item/drag-external-item-create-placeholder/drag-external-item-create-placeholder-request.d.ts

@@ -0,0 +1,6 @@
+import { FExternalItemBase } from '../../../f-external-item';
+export declare class DragExternalItemCreatePlaceholderRequest {
+    readonly externalItem: FExternalItemBase;
+    static readonly fToken: unique symbol;
+    constructor(externalItem: FExternalItemBase);
+}

package/f-draggable/drag-external-item/drag-external-item-create-placeholder/drag-external-item-create-placeholder.d.ts

@@ -0,0 +1,13 @@
+import { DragExternalItemCreatePlaceholderRequest } from './drag-external-item-create-placeholder-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragExternalItemCreatePlaceholder implements IExecution<DragExternalItemCreatePlaceholderRequest, HTMLElement | SVGElement> {
+    private readonly _browser;
+    private readonly _containerRef;
+    handle({ externalItem, }: DragExternalItemCreatePlaceholderRequest): HTMLElement | SVGElement;
+    private _fromTemplate;
+    private _fromHost;
+    private _createViewRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemCreatePlaceholder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemCreatePlaceholder>;
+}

package/f-draggable/drag-external-item/drag-external-item-create-placeholder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-external-item-create-placeholder';
+export * from './drag-external-item-create-placeholder-request';

package/f-draggable/drag-external-item/drag-external-item-create-preview/drag-external-item-create-preview-request.d.ts

@@ -0,0 +1,6 @@
+import { FExternalItemBase } from '../../../f-external-item';
+export declare class DragExternalItemCreatePreviewRequest {
+    readonly externalItem: FExternalItemBase;
+    static readonly fToken: unique symbol;
+    constructor(externalItem: FExternalItemBase);
+}

package/f-draggable/drag-external-item/drag-external-item-create-preview/drag-external-item-create-preview.d.ts

@@ -0,0 +1,14 @@
+import { DragExternalItemCreatePreviewRequest } from './drag-external-item-create-preview-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragExternalItemCreatePreview implements IExecution<DragExternalItemCreatePreviewRequest, HTMLElement | SVGElement> {
+    private readonly _browser;
+    private readonly _containerRef;
+    handle({ externalItem }: DragExternalItemCreatePreviewRequest): HTMLElement | SVGElement;
+    private _fromTemplate;
+    private _fromHost;
+    private _createViewRef;
+    private _setPreviewStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemCreatePreview, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemCreatePreview>;
+}

package/f-draggable/drag-external-item/drag-external-item-create-preview/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-external-item-create-preview';
+export * from './drag-external-item-create-preview-request';

package/f-draggable/drag-external-item/drag-external-item-finalize/drag-external-item-finalize-request.d.ts

@@ -0,0 +1,6 @@
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class DragExternalItemFinalizeRequest {
+    readonly event: IPointerEvent;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent);
+}

package/f-draggable/drag-external-item/drag-external-item-finalize/drag-external-item-finalize.d.ts

@@ -0,0 +1,21 @@
+import { DragExternalItemFinalizeRequest } from './drag-external-item-finalize-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragExternalItemFinalize implements IExecution<DragExternalItemFinalizeRequest, void> {
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _store;
+    private readonly _dragSession;
+    private readonly _browser;
+    private get _createNodeEmitter();
+    handle(request: DragExternalItemFinalizeRequest): void;
+    private _findExternalItemHandler;
+    private _getDestinationNodeOrGroupId;
+    private _getDropToGroupHandler;
+    private _getElementsFromPoint;
+    private _emitEvent;
+    private _isPointerInCanvasRect;
+    private _getPreviewRect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemFinalize, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemFinalize>;
+}

package/f-draggable/drag-external-item/drag-external-item-finalize/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-external-item-finalize';
+export * from './drag-external-item-finalize-request';

package/f-draggable/drag-external-item/drag-external-item-handler/drag-external-item-handler.d.ts

@@ -0,0 +1,50 @@
+import { IPoint } from '@foblex/2d';
+import { Injector } from '@angular/core';
+import { DragHandlerBase } from '../../infrastructure';
+import { FDragExternalItemStartEventData } from '../f-drag-external-item-start-event-data';
+import { FExternalItemBase } from '../../../f-external-item';
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class DragExternalItemHandler extends DragHandlerBase<unknown> {
+    private readonly _externalItem;
+    private readonly _pointerDownClientPosition;
+    protected readonly type = "external-item";
+    protected readonly kind = "drag-external-item";
+    protected data(): FDragExternalItemStartEventData<unknown>;
+    private readonly _result;
+    private readonly _mediator;
+    private readonly _browser;
+    private readonly _store;
+    private _previewEl?;
+    private _placeholderEl?;
+    private _startRect;
+    private _pointerDownRect;
+    private _absoluteOffsetFromFlow;
+    private _grabOffsetFromPointer;
+    private _originalParent?;
+    private _originalNextSibling?;
+    private readonly _originalDisplay;
+    private _applyConstraints;
+    constructor(injector: Injector, _externalItem: FExternalItemBase<unknown>, _pointerDownClientPosition: IPoint);
+    private get _host();
+    /** Overlay root: fullscreenElement (if any) or document.body */
+    private get _overlayRoot();
+    private get _transform();
+    private _initConstraints;
+    private _getStartRect;
+    prepareDragSequence(): void;
+    private _rememberOriginalPlacement;
+    private _createPreview;
+    private _createPlaceholder;
+    private _placePreviewIntoOverlay;
+    private _swapOriginalWithPlaceholderAndMoveOriginalIntoOverlay;
+    onPointerMove(delta: IPoint, event?: IPointerEvent): void;
+    onPointerUp(): void;
+    private _restoreOriginalInParent;
+    private _matchSize;
+    private _readAbsoluteRect;
+    private _toAbsolutePoint;
+    private _resolveDeltaFromPointer;
+    private _toFlowPoint;
+    private _getFlowHostAbsolutePosition;
+    private _clientToAbsolute;
+}

package/f-draggable/drag-external-item/drag-external-item-handler/index.d.ts

@@ -0,0 +1 @@
+export * from './drag-external-item-handler';

package/f-draggable/drag-external-item/drag-external-item-preparation/drag-external-item-preparation-request.d.ts

@@ -0,0 +1,8 @@
+import { FEventTrigger } from '../../../domain';
+import { IPointerEvent } from '../../../drag-toolkit';
+export declare class DragExternalItemPreparationRequest {
+    readonly event: IPointerEvent;
+    readonly fTrigger: FEventTrigger;
+    static readonly fToken: unique symbol;
+    constructor(event: IPointerEvent, fTrigger: FEventTrigger);
+}

package/f-draggable/drag-external-item/drag-external-item-preparation/drag-external-item-preparation.d.ts

@@ -0,0 +1,15 @@
+import { DragExternalItemPreparationRequest } from './drag-external-item-preparation-request';
+import { IExecution } from '@foblex/mediator';
+import * as i0 from "@angular/core";
+export declare class DragExternalItemPreparation implements IExecution<DragExternalItemPreparationRequest, void> {
+    private readonly _apiService;
+    private readonly _dragSession;
+    private readonly _store;
+    private readonly _injector;
+    private get _flowHost();
+    private get _transform();
+    handle({ event, fTrigger }: DragExternalItemPreparationRequest): void;
+    private _resolveExternalItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragExternalItemPreparation, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragExternalItemPreparation>;
+}

package/f-draggable/drag-external-item/drag-external-item-preparation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './drag-external-item-preparation';
+export * from './drag-external-item-preparation-request';