@foblex/flow 18.1.2 → 18.2.1

package/esm2022/f-draggable/drag-external-item/drag-external-item-finalize/drag-external-item-finalize-request.mjs

@@ -0,0 +1,8 @@
+export class DragExternalItemFinalizeRequest {
+    event;
+    static fToken = Symbol('DragExternalItemFinalizeRequest');
+    constructor(event) {
+        this.event = event;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1leHRlcm5hbC1pdGVtLWZpbmFsaXplLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9kcmFnLWV4dGVybmFsLWl0ZW0tZmluYWxpemUvZHJhZy1leHRlcm5hbC1pdGVtLWZpbmFsaXplLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLCtCQUErQjtJQUdkO0lBRjVCLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLGlDQUFpQyxDQUFDLENBQUM7SUFFbkUsWUFBNEIsS0FBb0I7UUFBcEIsVUFBSyxHQUFMLEtBQUssQ0FBZTtJQUFHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUG9pbnRlckV2ZW50IH0gZnJvbSAnLi4vLi4vLi4vZHJhZy10b29sa2l0JztcblxuZXhwb3J0IGNsYXNzIERyYWdFeHRlcm5hbEl0ZW1GaW5hbGl6ZVJlcXVlc3Qge1xuICBzdGF0aWMgcmVhZG9ubHkgZlRva2VuID0gU3ltYm9sKCdEcmFnRXh0ZXJuYWxJdGVtRmluYWxpemVSZXF1ZXN0Jyk7XG5cbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IGV2ZW50OiBJUG9pbnRlckV2ZW50KSB7fVxufVxuIl19

package/esm2022/f-draggable/drag-external-item/drag-external-item-finalize/drag-external-item-finalize.mjs

@@ -0,0 +1,75 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { DragExternalItemFinalizeRequest } from './drag-external-item-finalize-request';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FCreateNodeEvent } from '../f-create-node-event';
+import { FDragHandlerResult } from '../../infrastructure';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { isDragExternalItemHandler } from '../is-drag-external-item-handler';
+import { DropToGroupHandler } from '../../drop-to-group';
+import { BrowserService } from '@foblex/platform';
+import { GetNormalizedElementRectRequest } from '../../../domain';
+import * as i0 from "@angular/core";
+let DragExternalItemFinalize = class DragExternalItemFinalize {
+    _result = inject(FDragHandlerResult);
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    _dragSession = inject(FDraggableDataContext);
+    _browser = inject(BrowserService);
+    get _createNodeEmitter() {
+        return this._store.fDraggable?.fCreateNode;
+    }
+    handle(request) {
+        const handler = this._findExternalItemHandler();
+        if (!handler) {
+            return;
+        }
+        const targetContainerId = this._getDestinationNodeOrGroupId();
+        this._emitEvent(this._getElementsFromPoint(request.event.getPosition()), targetContainerId, request.event.getPosition());
+        handler.onPointerUp();
+        this._dragSession.draggableItems = [];
+    }
+    _findExternalItemHandler() {
+        return this._dragSession.draggableItems.find((x) => isDragExternalItemHandler(x));
+    }
+    _getDestinationNodeOrGroupId() {
+        const handler = this._getDropToGroupHandler();
+        const result = handler.activeTarget?.node.fId();
+        handler.onPointerUp?.();
+        return result;
+    }
+    _getDropToGroupHandler() {
+        const result = this._dragSession.draggableItems.find((x) => x instanceof DropToGroupHandler);
+        if (!result) {
+            throw new Error('NodeDragToParentDragHandler not found');
+        }
+        return result;
+    }
+    _getElementsFromPoint(position) {
+        return this._browser.document
+            .elementsFromPoint(position.x, position.y)
+            .filter((x) => !x.closest('.f-external-item') && !x.closest('.f-external-item-preview'));
+    }
+    _emitEvent(elements, destinationNodeOrGroupId, eventPosition) {
+        if (this._isPointerInCanvasRect(elements)) {
+            this._createNodeEmitter?.emit(new FCreateNodeEvent(this._getPreviewRect(), this._result.getData().externalItem.data(), destinationNodeOrGroupId, destinationNodeOrGroupId ? eventPosition : undefined));
+        }
+    }
+    _isPointerInCanvasRect(elements) {
+        return elements.length ? this._store.flowHost.contains(elements[0]) : false;
+    }
+    _getPreviewRect() {
+        return this._mediator.execute(new GetNormalizedElementRectRequest(this._result.getData().preview));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragExternalItemFinalize, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragExternalItemFinalize });
+};
+DragExternalItemFinalize = __decorate([
+    FExecutionRegister(DragExternalItemFinalizeRequest)
+], DragExternalItemFinalize);
+export { DragExternalItemFinalize };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragExternalItemFinalize, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-external-item-finalize.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-external-item/drag-external-item-finalize/drag-external-item-finalize.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, inject, Injectable } from '@angular/core';\nimport { DragExternalItemFinalizeRequest } from './drag-external-item-finalize-request';\nimport { IPoint, IRect } from '@foblex/2d';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FCreateNodeEvent } from '../f-create-node-event';\nimport { FDragHandlerResult } from '../../infrastructure';\nimport { FComponentsStore } from '../../../f-storage';\nimport { DragExternalItemHandler } from '../drag-external-item-handler';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { isDragExternalItemHandler } from '../is-drag-external-item-handler';\nimport { DropToGroupHandler } from '../../drop-to-group';\nimport { BrowserService } from '@foblex/platform';\nimport { GetNormalizedElementRectRequest } from '../../../domain';\nimport { IDragExternalItemDragResult } from '../i-drag-external-item-drag-result';\n\n@Injectable()\n@FExecutionRegister(DragExternalItemFinalizeRequest)\nexport class DragExternalItemFinalize implements IExecution<DragExternalItemFinalizeRequest, void> {\n  private readonly _result: FDragHandlerResult<IDragExternalItemDragResult> =\n    inject(FDragHandlerResult);\n\n  private readonly _mediator = inject(FMediator);\n  private readonly _store = inject(FComponentsStore);\n  private readonly _dragSession = inject(FDraggableDataContext);\n  private readonly _browser = inject(BrowserService);\n\n  private get _createNodeEmitter(): EventEmitter<FCreateNodeEvent> | undefined {\n    return this._store.fDraggable?.fCreateNode;\n  }\n\n  public handle(request: DragExternalItemFinalizeRequest): void {\n    const handler = this._findExternalItemHandler();\n    if (!handler) {\n      return;\n    }\n\n    const targetContainerId = this._getDestinationNodeOrGroupId();\n\n    this._emitEvent(\n      this._getElementsFromPoint(request.event.getPosition()),\n      targetContainerId,\n      request.event.getPosition(),\n    );\n\n    handler.onPointerUp();\n    this._dragSession.draggableItems = [];\n  }\n\n  private _findExternalItemHandler(): DragExternalItemHandler | undefined {\n    return this._dragSession.draggableItems.find((x) => isDragExternalItemHandler(x));\n  }\n\n  private _getDestinationNodeOrGroupId(): string | undefined {\n    const handler = this._getDropToGroupHandler();\n    const result = handler.activeTarget?.node.fId();\n    handler.onPointerUp?.();\n\n    return result;\n  }\n\n  private _getDropToGroupHandler(): DropToGroupHandler {\n    const result = this._dragSession.draggableItems.find((x) => x instanceof DropToGroupHandler);\n    if (!result) {\n      throw new Error('NodeDragToParentDragHandler not found');\n    }\n\n    return result;\n  }\n\n  private _getElementsFromPoint(position: IPoint): HTMLElement[] {\n    return this._browser.document\n      .elementsFromPoint(position.x, position.y)\n      .filter(\n        (x) => !x.closest('.f-external-item') && !x.closest('.f-external-item-preview'),\n      ) as HTMLElement[];\n  }\n\n  private _emitEvent(\n    elements: HTMLElement[],\n    destinationNodeOrGroupId: string | undefined,\n    eventPosition: IPoint,\n  ): void {\n    if (this._isPointerInCanvasRect(elements)) {\n      this._createNodeEmitter?.emit(\n        new FCreateNodeEvent(\n          this._getPreviewRect(),\n          this._result.getData().externalItem.data(),\n          destinationNodeOrGroupId,\n          destinationNodeOrGroupId ? eventPosition : undefined,\n        ),\n      );\n    }\n  }\n\n  private _isPointerInCanvasRect(elements: HTMLElement[]): boolean {\n    return elements.length ? this._store.flowHost.contains(elements[0]) : false;\n  }\n\n  private _getPreviewRect(): IRect {\n    return this._mediator.execute<IRect>(\n      new GetNormalizedElementRectRequest(this._result.getData().preview),\n    );\n  }\n}\n"]}

package/esm2022/f-draggable/drag-external-item/drag-external-item-finalize/index.mjs

@@ -0,0 +1,3 @@
+export * from './drag-external-item-finalize';
+export * from './drag-external-item-finalize-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9kcmFnLWV4dGVybmFsLWl0ZW0tZmluYWxpemUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kcmFnLWV4dGVybmFsLWl0ZW0tZmluYWxpemUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2RyYWctZXh0ZXJuYWwtaXRlbS1maW5hbGl6ZS1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/f-draggable/drag-external-item/drag-external-item-handler/drag-external-item-handler.mjs

@@ -0,0 +1,206 @@
+import { Point, PointExtensions, RectExtensions } from '@foblex/2d';
+import { BrowserService } from '@foblex/platform';
+import { FMediator } from '@foblex/mediator';
+import { DragHandlerBase, FDragHandlerResult } from '../../infrastructure';
+import { FDragExternalItemStartEventData } from '../f-drag-external-item-start-event-data';
+import { FComponentsStore } from '../../../f-storage';
+import { infinityMinMax } from '../../../utils';
+import { ExternalRectConstraint } from '../constraints';
+import { GetNormalizedElementRectRequest } from '../../../domain';
+import { DragExternalItemCreatePreviewRequest } from '../drag-external-item-create-preview';
+import { DragExternalItemCreatePlaceholderRequest } from '../drag-external-item-create-placeholder';
+export class DragExternalItemHandler extends DragHandlerBase {
+    _externalItem;
+    _pointerDownClientPosition;
+    type = 'external-item';
+    kind = 'drag-external-item';
+    data() {
+        return new FDragExternalItemStartEventData(this._externalItem.data());
+    }
+    _result;
+    _mediator;
+    _browser;
+    _store;
+    _previewEl;
+    _placeholderEl;
+    _startRect = RectExtensions.initialize();
+    _pointerDownRect = RectExtensions.initialize();
+    _absoluteOffsetFromFlow = PointExtensions.initialize();
+    _grabOffsetFromPointer = PointExtensions.initialize();
+    _originalParent;
+    _originalNextSibling;
+    _originalDisplay;
+    _applyConstraints = (d) => d;
+    constructor(injector, _externalItem, _pointerDownClientPosition) {
+        super();
+        this._externalItem = _externalItem;
+        this._pointerDownClientPosition = _pointerDownClientPosition;
+        this._store = injector.get(FComponentsStore);
+        this._result = injector.get(FDragHandlerResult);
+        this._mediator = injector.get(FMediator);
+        this._browser = injector.get(BrowserService);
+        this._originalDisplay = this._host.style.display;
+        this._initConstraints(injector);
+    }
+    get _host() {
+        return this._externalItem.hostElement;
+    }
+    /** Overlay root: fullscreenElement (if any) or document.body */
+    get _overlayRoot() {
+        return this._browser.document.fullscreenElement ?? this._browser.document.body;
+    }
+    get _transform() {
+        return this._store.transform;
+    }
+    _initConstraints(injector) {
+        this._startRect = this._getStartRect();
+        const constraint = new ExternalRectConstraint(injector, this._startRect, infinityMinMax());
+        this._applyConstraints = (delta) => constraint.limit(delta);
+    }
+    _getStartRect() {
+        return this._mediator.execute(new GetNormalizedElementRectRequest(this._externalItem.hostElement));
+    }
+    prepareDragSequence() {
+        this._pointerDownRect = this._readAbsoluteRect(this._host);
+        this._absoluteOffsetFromFlow = Point.fromPoint(this._pointerDownRect).sub(this._toAbsolutePoint(this._startRect));
+        this._grabOffsetFromPointer = this._clientToAbsolute(this._pointerDownClientPosition).sub(this._pointerDownRect);
+        this._rememberOriginalPlacement();
+        this._previewEl = this._createPreview();
+        this._placeholderEl = this._createPlaceholder();
+        // 1) Preview goes to overlay
+        this._placePreviewIntoOverlay();
+        // 2) Placeholder replaces original *in its parent*
+        // 3) Original is moved into overlay (hidden) — this preserves current behavior
+        this._swapOriginalWithPlaceholderAndMoveOriginalIntoOverlay();
+        this._result.setData({
+            preview: this._previewEl,
+            externalItem: this._externalItem,
+        });
+    }
+    _rememberOriginalPlacement() {
+        const parent = this._host.parentNode;
+        if (!parent) {
+            // possible if host already detached
+            this._originalParent = undefined;
+            this._originalNextSibling = null;
+            return;
+        }
+        this._originalParent = parent;
+        this._originalNextSibling = this._host.nextSibling;
+    }
+    _createPreview() {
+        const el = this._mediator.execute(new DragExternalItemCreatePreviewRequest(this._externalItem));
+        if (this._externalItem.previewMatchSize()) {
+            this._matchSize(el, this._pointerDownRect);
+        }
+        el.style.transform = _translate(this._pointerDownRect);
+        return el;
+    }
+    _createPlaceholder() {
+        return this._mediator.execute(new DragExternalItemCreatePlaceholderRequest(this._externalItem));
+    }
+    _placePreviewIntoOverlay() {
+        // Ensure it is in overlay root (fullscreen or body)
+        this._overlayRoot.appendChild(this._previewEl);
+    }
+    _swapOriginalWithPlaceholderAndMoveOriginalIntoOverlay() {
+        const parent = this._originalParent;
+        const placeholder = this._placeholderEl;
+        if (!parent || !placeholder)
+            return;
+        // Replace original in its parent with placeholder
+        const detachedOriginal = parent.replaceChild(placeholder, this._host);
+        // Keep original alive but out of layout (current behavior): move to overlay and hide
+        this._overlayRoot.appendChild(detachedOriginal);
+        this._host.style.display = 'none';
+    }
+    onPointerMove(delta, event) {
+        if (!this._previewEl)
+            return;
+        const desiredDelta = this._resolveDeltaFromPointer(delta, event);
+        const constrained = this._applyConstraints(desiredDelta);
+        const pointInFlow = Point.fromPoint(this._startRect).add(constrained);
+        const next = this._toAbsolutePoint(pointInFlow).add(this._absoluteOffsetFromFlow);
+        this._previewEl.style.transform = _translate(next);
+    }
+    onPointerUp() {
+        // Remove preview
+        if (this._previewEl && this._previewEl.parentNode) {
+            this._previewEl.parentNode.removeChild(this._previewEl);
+        }
+        // Restore original back into its place, remove placeholder
+        this._restoreOriginalInParent();
+        // Restore display
+        this._host.style.display = this._originalDisplay || 'block';
+        // cleanup refs
+        this._previewEl = undefined;
+        this._placeholderEl = undefined;
+        this._originalParent = undefined;
+        this._originalNextSibling = null;
+    }
+    _restoreOriginalInParent() {
+        const parent = this._originalParent;
+        const placeholder = this._placeholderEl;
+        if (!parent || !placeholder)
+            return;
+        // placeholder is currently in parent; swap back
+        if (placeholder.parentNode === parent) {
+            parent.replaceChild(this._host, placeholder);
+            return;
+        }
+        // fallback: if placeholder somehow moved, re-insert original at remembered position
+        if (this._originalNextSibling && this._originalNextSibling.parentNode === parent) {
+            parent.insertBefore(this._host, this._originalNextSibling);
+        }
+        else {
+            parent.appendChild(this._host);
+        }
+    }
+    _matchSize(target, rect) {
+        target.style.width = `${rect.width}px`;
+        target.style.height = `${rect.height}px`;
+    }
+    _readAbsoluteRect(el) {
+        const rect = el.getBoundingClientRect();
+        // page offsets (works for most cases). if you ever support visualViewport, can refine.
+        const scrollTop = this._browser.window.pageYOffset || this._browser.document.documentElement.scrollTop;
+        const scrollLeft = this._browser.window.pageXOffset || this._browser.document.documentElement.scrollLeft;
+        return RectExtensions.initialize(rect.left + scrollLeft, rect.top + scrollTop, rect.width, rect.height);
+    }
+    _toAbsolutePoint(pointInFlow) {
+        const offset = Point.fromPoint(this._transform.position).add(this._transform.scaledPosition);
+        return Point.fromPoint(pointInFlow)
+            .mult(this._transform.scale)
+            .add(offset)
+            .add(this._getFlowHostAbsolutePosition());
+    }
+    _resolveDeltaFromPointer(fallbackDelta, event) {
+        const pointerClient = event?.getPosition();
+        if (!pointerClient) {
+            return fallbackDelta;
+        }
+        const desiredPreviewAbsolutePoint = this._clientToAbsolute(pointerClient).sub(this._grabOffsetFromPointer);
+        const desiredFlowPoint = this._toFlowPoint(desiredPreviewAbsolutePoint);
+        return Point.fromPoint(desiredFlowPoint).sub(this._startRect);
+    }
+    _toFlowPoint(absolutePoint) {
+        const hostAbsolute = this._getFlowHostAbsolutePosition();
+        const offset = Point.fromPoint(this._transform.position).add(this._transform.scaledPosition);
+        return Point.fromPoint(absolutePoint).sub(hostAbsolute).sub(offset).div(this._transform.scale);
+    }
+    _getFlowHostAbsolutePosition() {
+        const hostRect = this._store.flowHost.getBoundingClientRect();
+        const scrollTop = this._browser.window.pageYOffset || this._browser.document.documentElement.scrollTop;
+        const scrollLeft = this._browser.window.pageXOffset || this._browser.document.documentElement.scrollLeft;
+        return PointExtensions.initialize(hostRect.left + scrollLeft, hostRect.top + scrollTop);
+    }
+    _clientToAbsolute(clientPoint) {
+        const scrollTop = this._browser.window.pageYOffset || this._browser.document.documentElement.scrollTop;
+        const scrollLeft = this._browser.window.pageXOffset || this._browser.document.documentElement.scrollLeft;
+        return Point.fromPoint(clientPoint).add(PointExtensions.initialize(scrollLeft, scrollTop));
+    }
+}
+function _translate({ x, y }) {
+    return `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-external-item-handler.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/drag-external-item/drag-external-item-handler/drag-external-item-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint, IRect, ITransformModel, Point, PointExtensions, RectExtensions } from '@foblex/2d';\nimport { BrowserService } from '@foblex/platform';\nimport { FMediator } from '@foblex/mediator';\nimport { Injector } from '@angular/core';\nimport { DragHandlerBase, FDragHandlerResult } from '../../infrastructure';\nimport { FDragExternalItemStartEventData } from '../f-drag-external-item-start-event-data';\nimport { FComponentsStore } from '../../../f-storage';\nimport { infinityMinMax } from '../../../utils';\nimport { ExternalRectConstraint } from '../constraints';\nimport { GetNormalizedElementRectRequest } from '../../../domain';\nimport { IDragExternalItemDragResult } from '../i-drag-external-item-drag-result';\nimport { DragExternalItemCreatePreviewRequest } from '../drag-external-item-create-preview';\nimport { DragExternalItemCreatePlaceholderRequest } from '../drag-external-item-create-placeholder';\nimport { FExternalItemBase } from '../../../f-external-item';\nimport { IPointerEvent } from '../../../drag-toolkit';\n\nexport class DragExternalItemHandler extends DragHandlerBase<unknown> {\n  protected readonly type = 'external-item';\n  protected readonly kind = 'drag-external-item';\n\n  protected override data() {\n    return new FDragExternalItemStartEventData(this._externalItem.data());\n  }\n\n  private readonly _result: FDragHandlerResult<IDragExternalItemDragResult>;\n  private readonly _mediator: FMediator;\n  private readonly _browser: BrowserService;\n  private readonly _store: FComponentsStore;\n\n  private _previewEl?: HTMLElement | SVGElement;\n  private _placeholderEl?: HTMLElement | SVGElement;\n\n  private _startRect: IRect = RectExtensions.initialize();\n  private _pointerDownRect: IRect = RectExtensions.initialize();\n  private _absoluteOffsetFromFlow: IPoint = PointExtensions.initialize();\n  private _grabOffsetFromPointer: IPoint = PointExtensions.initialize();\n\n  private _originalParent?: Node;\n  private _originalNextSibling?: ChildNode | null;\n  private readonly _originalDisplay: string;\n\n  private _applyConstraints: (delta: IPoint) => IPoint = (d) => d;\n\n  constructor(\n    injector: Injector,\n    private readonly _externalItem: FExternalItemBase<unknown>,\n    private readonly _pointerDownClientPosition: IPoint,\n  ) {\n    super();\n\n    this._store = injector.get(FComponentsStore);\n    this._result = injector.get(FDragHandlerResult);\n    this._mediator = injector.get(FMediator);\n    this._browser = injector.get(BrowserService);\n\n    this._originalDisplay = this._host.style.display;\n\n    this._initConstraints(injector);\n  }\n\n  private get _host(): HTMLElement | SVGElement {\n    return this._externalItem.hostElement;\n  }\n\n  /** Overlay root: fullscreenElement (if any) or document.body */\n  private get _overlayRoot(): Element {\n    return this._browser.document.fullscreenElement ?? this._browser.document.body;\n  }\n\n  private get _transform(): ITransformModel {\n    return this._store.transform;\n  }\n\n  private _initConstraints(injector: Injector): void {\n    this._startRect = this._getStartRect();\n    const constraint = new ExternalRectConstraint(injector, this._startRect, infinityMinMax());\n\n    this._applyConstraints = (delta: IPoint) => constraint.limit(delta);\n  }\n\n  private _getStartRect(): IRect {\n    return this._mediator.execute<IRect>(\n      new GetNormalizedElementRectRequest(this._externalItem.hostElement),\n    );\n  }\n\n  public override prepareDragSequence(): void {\n    this._pointerDownRect = this._readAbsoluteRect(this._host);\n    this._absoluteOffsetFromFlow = Point.fromPoint(this._pointerDownRect).sub(\n      this._toAbsolutePoint(this._startRect),\n    );\n    this._grabOffsetFromPointer = this._clientToAbsolute(this._pointerDownClientPosition).sub(\n      this._pointerDownRect,\n    );\n\n    this._rememberOriginalPlacement();\n\n    this._previewEl = this._createPreview();\n    this._placeholderEl = this._createPlaceholder();\n\n    // 1) Preview goes to overlay\n    this._placePreviewIntoOverlay();\n\n    // 2) Placeholder replaces original *in its parent*\n    // 3) Original is moved into overlay (hidden) — this preserves current behavior\n    this._swapOriginalWithPlaceholderAndMoveOriginalIntoOverlay();\n\n    this._result.setData({\n      preview: this._previewEl,\n      externalItem: this._externalItem,\n    });\n  }\n\n  private _rememberOriginalPlacement(): void {\n    const parent = this._host.parentNode;\n    if (!parent) {\n      // possible if host already detached\n      this._originalParent = undefined;\n      this._originalNextSibling = null;\n\n      return;\n    }\n\n    this._originalParent = parent;\n    this._originalNextSibling = this._host.nextSibling;\n  }\n\n  private _createPreview(): HTMLElement | SVGElement {\n    const el = this._mediator.execute<HTMLElement>(\n      new DragExternalItemCreatePreviewRequest(this._externalItem),\n    );\n\n    if (this._externalItem.previewMatchSize()) {\n      this._matchSize(el as HTMLElement, this._pointerDownRect);\n    }\n\n    el.style.transform = _translate(this._pointerDownRect);\n\n    return el;\n  }\n\n  private _createPlaceholder(): HTMLElement | SVGElement {\n    return this._mediator.execute<HTMLElement>(\n      new DragExternalItemCreatePlaceholderRequest(this._externalItem),\n    );\n  }\n\n  private _placePreviewIntoOverlay(): void {\n    // Ensure it is in overlay root (fullscreen or body)\n    this._overlayRoot.appendChild(this._previewEl!);\n  }\n\n  private _swapOriginalWithPlaceholderAndMoveOriginalIntoOverlay(): void {\n    const parent = this._originalParent;\n    const placeholder = this._placeholderEl;\n\n    if (!parent || !placeholder) return;\n\n    // Replace original in its parent with placeholder\n    const detachedOriginal = parent.replaceChild(placeholder, this._host);\n\n    // Keep original alive but out of layout (current behavior): move to overlay and hide\n    this._overlayRoot.appendChild(detachedOriginal);\n    (this._host as HTMLElement).style.display = 'none';\n  }\n\n  public override onPointerMove(delta: IPoint, event?: IPointerEvent): void {\n    if (!this._previewEl) return;\n\n    const desiredDelta = this._resolveDeltaFromPointer(delta, event);\n    const constrained = this._applyConstraints(desiredDelta);\n    const pointInFlow = Point.fromPoint(this._startRect).add(constrained);\n    const next = this._toAbsolutePoint(pointInFlow).add(this._absoluteOffsetFromFlow);\n    this._previewEl.style.transform = _translate(next);\n  }\n\n  public override onPointerUp(): void {\n    // Remove preview\n    if (this._previewEl && this._previewEl.parentNode) {\n      this._previewEl.parentNode.removeChild(this._previewEl);\n    }\n\n    // Restore original back into its place, remove placeholder\n    this._restoreOriginalInParent();\n\n    // Restore display\n    (this._host as HTMLElement).style.display = this._originalDisplay || 'block';\n\n    // cleanup refs\n    this._previewEl = undefined;\n    this._placeholderEl = undefined;\n    this._originalParent = undefined;\n    this._originalNextSibling = null;\n  }\n\n  private _restoreOriginalInParent(): void {\n    const parent = this._originalParent;\n    const placeholder = this._placeholderEl;\n\n    if (!parent || !placeholder) return;\n\n    // placeholder is currently in parent; swap back\n    if (placeholder.parentNode === parent) {\n      parent.replaceChild(this._host, placeholder);\n\n      return;\n    }\n\n    // fallback: if placeholder somehow moved, re-insert original at remembered position\n    if (this._originalNextSibling && this._originalNextSibling.parentNode === parent) {\n      parent.insertBefore(this._host, this._originalNextSibling);\n    } else {\n      parent.appendChild(this._host);\n    }\n  }\n\n  private _matchSize(target: HTMLElement, rect: IRect): void {\n    target.style.width = `${rect.width}px`;\n    target.style.height = `${rect.height}px`;\n  }\n\n  private _readAbsoluteRect(el: Element): IRect {\n    const rect = el.getBoundingClientRect();\n\n    // page offsets (works for most cases). if you ever support visualViewport, can refine.\n    const scrollTop =\n      this._browser.window.pageYOffset || this._browser.document.documentElement.scrollTop;\n    const scrollLeft =\n      this._browser.window.pageXOffset || this._browser.document.documentElement.scrollLeft;\n\n    return RectExtensions.initialize(\n      rect.left + scrollLeft,\n      rect.top + scrollTop,\n      rect.width,\n      rect.height,\n    );\n  }\n\n  private _toAbsolutePoint(pointInFlow: IPoint): Point {\n    const offset = Point.fromPoint(this._transform.position).add(this._transform.scaledPosition);\n\n    return Point.fromPoint(pointInFlow)\n      .mult(this._transform.scale)\n      .add(offset)\n      .add(this._getFlowHostAbsolutePosition());\n  }\n\n  private _resolveDeltaFromPointer(fallbackDelta: IPoint, event?: IPointerEvent): IPoint {\n    const pointerClient = event?.getPosition();\n    if (!pointerClient) {\n      return fallbackDelta;\n    }\n\n    const desiredPreviewAbsolutePoint = this._clientToAbsolute(pointerClient).sub(\n      this._grabOffsetFromPointer,\n    );\n    const desiredFlowPoint = this._toFlowPoint(desiredPreviewAbsolutePoint);\n\n    return Point.fromPoint(desiredFlowPoint).sub(this._startRect);\n  }\n\n  private _toFlowPoint(absolutePoint: IPoint): Point {\n    const hostAbsolute = this._getFlowHostAbsolutePosition();\n    const offset = Point.fromPoint(this._transform.position).add(this._transform.scaledPosition);\n\n    return Point.fromPoint(absolutePoint).sub(hostAbsolute).sub(offset).div(this._transform.scale);\n  }\n\n  private _getFlowHostAbsolutePosition(): IPoint {\n    const hostRect = this._store.flowHost.getBoundingClientRect();\n    const scrollTop =\n      this._browser.window.pageYOffset || this._browser.document.documentElement.scrollTop;\n    const scrollLeft =\n      this._browser.window.pageXOffset || this._browser.document.documentElement.scrollLeft;\n\n    return PointExtensions.initialize(hostRect.left + scrollLeft, hostRect.top + scrollTop);\n  }\n\n  private _clientToAbsolute(clientPoint: IPoint): Point {\n    const scrollTop =\n      this._browser.window.pageYOffset || this._browser.document.documentElement.scrollTop;\n    const scrollLeft =\n      this._browser.window.pageXOffset || this._browser.document.documentElement.scrollLeft;\n\n    return Point.fromPoint(clientPoint).add(PointExtensions.initialize(scrollLeft, scrollTop));\n  }\n}\n\nfunction _translate({ x, y }: IPoint): string {\n  return `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;\n}\n"]}

package/esm2022/f-draggable/drag-external-item/drag-external-item-handler/index.mjs

@@ -0,0 +1,2 @@
+export * from './drag-external-item-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9kcmFnLWV4dGVybmFsLWl0ZW0taGFuZGxlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kcmFnLWV4dGVybmFsLWl0ZW0taGFuZGxlcic7XG4iXX0=

package/esm2022/f-draggable/drag-external-item/drag-external-item-preparation/drag-external-item-preparation-request.mjs

@@ -0,0 +1,10 @@
+export class DragExternalItemPreparationRequest {
+    event;
+    fTrigger;
+    static fToken = Symbol('DragExternalItemPreparationRequest');
+    constructor(event, fTrigger) {
+        this.event = event;
+        this.fTrigger = fTrigger;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1leHRlcm5hbC1pdGVtLXByZXBhcmF0aW9uLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9kcmFnLWV4dGVybmFsLWl0ZW0tcHJlcGFyYXRpb24vZHJhZy1leHRlcm5hbC1pdGVtLXByZXBhcmF0aW9uLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFPLGtDQUFrQztJQUkzQjtJQUNBO0lBSmxCLE1BQU0sQ0FBVSxNQUFNLEdBQUcsTUFBTSxDQUFDLG9DQUFvQyxDQUFDLENBQUM7SUFFdEUsWUFDa0IsS0FBb0IsRUFDcEIsUUFBdUI7UUFEdkIsVUFBSyxHQUFMLEtBQUssQ0FBZTtRQUNwQixhQUFRLEdBQVIsUUFBUSxDQUFlO0lBQ3RDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGRXZlbnRUcmlnZ2VyIH0gZnJvbSAnLi4vLi4vLi4vZG9tYWluJztcbmltcG9ydCB7IElQb2ludGVyRXZlbnQgfSBmcm9tICcuLi8uLi8uLi9kcmFnLXRvb2xraXQnO1xuXG5leHBvcnQgY2xhc3MgRHJhZ0V4dGVybmFsSXRlbVByZXBhcmF0aW9uUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ0RyYWdFeHRlcm5hbEl0ZW1QcmVwYXJhdGlvblJlcXVlc3QnKTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgcmVhZG9ubHkgZXZlbnQ6IElQb2ludGVyRXZlbnQsXG4gICAgcHVibGljIHJlYWRvbmx5IGZUcmlnZ2VyOiBGRXZlbnRUcmlnZ2VyLFxuICApIHt9XG59XG4iXX0=

package/esm2022/f-draggable/drag-external-item/drag-external-item-preparation/drag-external-item-preparation.mjs

@@ -0,0 +1,55 @@
+import { __decorate } from "tslib";
+import { inject, Injectable, Injector } from '@angular/core';
+import { DragExternalItemPreparationRequest } from './drag-external-item-preparation-request';
+import { Point } from '@foblex/2d';
+import { FExecutionRegister } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { FExternalItemService } from '../../../f-external-item';
+import { DragExternalItemHandler, FDraggableDataContext } from '../../../f-draggable';
+import { isValidEventTrigger } from '../../../domain';
+import * as i0 from "@angular/core";
+let DragExternalItemPreparation = class DragExternalItemPreparation {
+    _apiService = inject(FExternalItemService);
+    _dragSession = inject(FDraggableDataContext);
+    _store = inject(FComponentsStore);
+    _injector = inject(Injector);
+    get _flowHost() {
+        return this._store.flowHost;
+    }
+    get _transform() {
+        return this._store.transform;
+    }
+    handle({ event, fTrigger }) {
+        if (!this._dragSession.isEmpty()) {
+            return;
+        }
+        if (!isValidEventTrigger(event.originalEvent, fTrigger)) {
+            return;
+        }
+        const item = this._resolveExternalItem(event.targetElement);
+        if (!item || item.disabled()) {
+            return;
+        }
+        const scale = this._transform.scale ?? 1;
+        this._dragSession.onPointerDownScale = scale;
+        this._dragSession.onPointerDownPosition = Point.fromPoint(event.getPosition())
+            .elementTransform(this._flowHost)
+            .div(scale);
+        this._dragSession.draggableItems = [
+            new DragExternalItemHandler(this._injector, item, event.getPosition()),
+        ];
+    }
+    _resolveExternalItem(target) {
+        return this._apiService.getByElement(target);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragExternalItemPreparation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragExternalItemPreparation });
+};
+DragExternalItemPreparation = __decorate([
+    FExecutionRegister(DragExternalItemPreparationRequest)
+], DragExternalItemPreparation);
+export { DragExternalItemPreparation };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DragExternalItemPreparation, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-external-item/drag-external-item-preparation/index.mjs

@@ -0,0 +1,3 @@
+export * from './drag-external-item-preparation';
+export * from './drag-external-item-preparation-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9kcmFnLWV4dGVybmFsLWl0ZW0tcHJlcGFyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxjQUFjLDBDQUEwQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kcmFnLWV4dGVybmFsLWl0ZW0tcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL2RyYWctZXh0ZXJuYWwtaXRlbS1wcmVwYXJhdGlvbi1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/f-draggable/drag-external-item/f-create-node-event.mjs

@@ -0,0 +1,35 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class FCreateNodeEvent {
+    // -----------------------------
+    // Preferred API
+    // -----------------------------
+    /** Rect of the dragged external item at the moment of drop (in flow coordinates). */
+    externalItemRect;
+    /** External item data payload. */
+    data;
+    /** Id of node/group where item was dropped (if any). */
+    targetContainerId;
+    /** Pointer drop position in flow coordinates (if provided). */
+    dropPosition;
+    // -----------------------------
+    // Deprecated compatibility API
+    // -----------------------------
+    /** @deprecated Use `externalItemRect` */
+    rect;
+    /** @deprecated Use `targetContainerId` */
+    fTargetNode;
+    /** @deprecated Use `dropPosition` */
+    fDropPosition;
+    constructor(externalItemRect, data, targetContainerId, dropPosition) {
+        // new
+        this.externalItemRect = externalItemRect;
+        this.data = data;
+        this.targetContainerId = targetContainerId;
+        this.dropPosition = dropPosition;
+        // legacy aliases (same values / references)
+        this.rect = externalItemRect;
+        this.fTargetNode = targetContainerId;
+        this.fDropPosition = dropPosition;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-external-item/f-drag-external-item-start-event-data.mjs

@@ -0,0 +1,7 @@
+export class FDragExternalItemStartEventData {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1kcmFnLWV4dGVybmFsLWl0ZW0tc3RhcnQtZXZlbnQtZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvZHJhZy1leHRlcm5hbC1pdGVtL2YtZHJhZy1leHRlcm5hbC1pdGVtLXN0YXJ0LWV2ZW50LWRhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLCtCQUErQjtJQUNkO0lBQTVCLFlBQTRCLElBQU87UUFBUCxTQUFJLEdBQUosSUFBSSxDQUFHO0lBQUcsQ0FBQztDQUN4QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBGRHJhZ0V4dGVybmFsSXRlbVN0YXJ0RXZlbnREYXRhPFQ+IHtcbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IGRhdGE6IFQpIHt9XG59XG4iXX0=

package/esm2022/f-draggable/drag-external-item/i-drag-external-item-drag-result.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaS1kcmFnLWV4dGVybmFsLWl0ZW0tZHJhZy1yZXN1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9pLWRyYWctZXh0ZXJuYWwtaXRlbS1kcmFnLXJlc3VsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRkV4dGVybmFsSXRlbUJhc2UgfSBmcm9tICcuLi8uLi9mLWV4dGVybmFsLWl0ZW0nO1xuXG5leHBvcnQgaW50ZXJmYWNlIElEcmFnRXh0ZXJuYWxJdGVtRHJhZ1Jlc3VsdCB7XG4gIHByZXZpZXc6IEhUTUxFbGVtZW50IHwgU1ZHRWxlbWVudDtcbiAgZXh0ZXJuYWxJdGVtOiBGRXh0ZXJuYWxJdGVtQmFzZTx1bmtub3duPjtcbn1cbiJdfQ==

package/esm2022/f-draggable/drag-external-item/index.mjs

@@ -0,0 +1,13 @@
+export * from './constraints';
+export * from './drag-external-item-create-placeholder';
+export * from './drag-external-item-create-preview';
+export * from './drag-external-item-finalize';
+export * from './drag-external-item-handler';
+export * from './drag-external-item-preparation';
+export * from './prevent-default-is-external-item';
+export * from './f-create-node-event';
+export * from './f-drag-external-item-start-event-data';
+export * from './i-drag-external-item-drag-result';
+export * from './is-drag-external-item-handler';
+export * from './providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHlDQUF5QyxDQUFDO0FBQ3hELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb25zdHJhaW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2RyYWctZXh0ZXJuYWwtaXRlbS1jcmVhdGUtcGxhY2Vob2xkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWV4dGVybmFsLWl0ZW0tY3JlYXRlLXByZXZpZXcnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWV4dGVybmFsLWl0ZW0tZmluYWxpemUnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWV4dGVybmFsLWl0ZW0taGFuZGxlcic7XG5leHBvcnQgKiBmcm9tICcuL2RyYWctZXh0ZXJuYWwtaXRlbS1wcmVwYXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3ByZXZlbnQtZGVmYXVsdC1pcy1leHRlcm5hbC1pdGVtJztcbmV4cG9ydCAqIGZyb20gJy4vZi1jcmVhdGUtbm9kZS1ldmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2YtZHJhZy1leHRlcm5hbC1pdGVtLXN0YXJ0LWV2ZW50LWRhdGEnO1xuZXhwb3J0ICogZnJvbSAnLi9pLWRyYWctZXh0ZXJuYWwtaXRlbS1kcmFnLXJlc3VsdCc7XG5leHBvcnQgKiBmcm9tICcuL2lzLWRyYWctZXh0ZXJuYWwtaXRlbS1oYW5kbGVyJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXJzJztcbiJdfQ==

package/esm2022/f-draggable/drag-external-item/is-drag-external-item-handler.mjs

@@ -0,0 +1,7 @@
+export const DRAG_EXTERNAL_ITEM_HANDLER_TYPE = 'external-item';
+export const DRAG_EXTERNAL_ITEM_HANDLER_KIND = 'drag-external-item';
+export function isDragExternalItemHandler(value) {
+    return (value.getEvent().kind === DRAG_EXTERNAL_ITEM_HANDLER_KIND ||
+        value.getEvent().fEventType === DRAG_EXTERNAL_ITEM_HANDLER_TYPE);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZHJhZy1leHRlcm5hbC1pdGVtLWhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9pcy1kcmFnLWV4dGVybmFsLWl0ZW0taGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBRyxlQUFlLENBQUM7QUFDL0QsTUFBTSxDQUFDLE1BQU0sK0JBQStCLEdBQUcsb0JBQW9CLENBQUM7QUFFcEUsTUFBTSxVQUFVLHlCQUF5QixDQUN2QyxLQUErQjtJQUUvQixPQUFPLENBQ0wsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLElBQUksS0FBSywrQkFBK0I7UUFDekQsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFVBQVUsS0FBSywrQkFBK0IsQ0FDaEUsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEcmFnSGFuZGxlckJhc2UgfSBmcm9tICcuLi9pbmZyYXN0cnVjdHVyZSc7XG5pbXBvcnQgeyBEcmFnRXh0ZXJuYWxJdGVtSGFuZGxlciB9IGZyb20gJy4vZHJhZy1leHRlcm5hbC1pdGVtLWhhbmRsZXInO1xuXG5leHBvcnQgY29uc3QgRFJBR19FWFRFUk5BTF9JVEVNX0hBTkRMRVJfVFlQRSA9ICdleHRlcm5hbC1pdGVtJztcbmV4cG9ydCBjb25zdCBEUkFHX0VYVEVSTkFMX0lURU1fSEFORExFUl9LSU5EID0gJ2RyYWctZXh0ZXJuYWwtaXRlbSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0RyYWdFeHRlcm5hbEl0ZW1IYW5kbGVyKFxuICB2YWx1ZTogRHJhZ0hhbmRsZXJCYXNlPHVua25vd24+LFxuKTogdmFsdWUgaXMgRHJhZ0V4dGVybmFsSXRlbUhhbmRsZXIge1xuICByZXR1cm4gKFxuICAgIHZhbHVlLmdldEV2ZW50KCkua2luZCA9PT0gRFJBR19FWFRFUk5BTF9JVEVNX0hBTkRMRVJfS0lORCB8fFxuICAgIHZhbHVlLmdldEV2ZW50KCkuZkV2ZW50VHlwZSA9PT0gRFJBR19FWFRFUk5BTF9JVEVNX0hBTkRMRVJfVFlQRVxuICApO1xufVxuIl19

package/esm2022/f-draggable/drag-external-item/prevent-default-is-external-item/index.mjs

@@ -0,0 +1,3 @@
+export * from './prevent-default-is-external-item';
+export * from './prevent-default-is-external-item-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL2RyYWctZXh0ZXJuYWwtaXRlbS9wcmV2ZW50LWRlZmF1bHQtaXMtZXh0ZXJuYWwtaXRlbS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDO0FBRW5ELGNBQWMsNENBQTRDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3ByZXZlbnQtZGVmYXVsdC1pcy1leHRlcm5hbC1pdGVtJztcblxuZXhwb3J0ICogZnJvbSAnLi9wcmV2ZW50LWRlZmF1bHQtaXMtZXh0ZXJuYWwtaXRlbS1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/f-draggable/drag-external-item/prevent-default-is-external-item/prevent-default-is-external-item-request.mjs

@@ -0,0 +1,8 @@
+export class PreventDefaultIsExternalItemRequest {
+    event;
+    static fToken = Symbol('PreventDefaultIsExternalItemRequest');
+    constructor(event) {
+        this.event = event;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmVudC1kZWZhdWx0LWlzLWV4dGVybmFsLWl0ZW0tcmVxdWVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvZHJhZy1leHRlcm5hbC1pdGVtL3ByZXZlbnQtZGVmYXVsdC1pcy1leHRlcm5hbC1pdGVtL3ByZXZlbnQtZGVmYXVsdC1pcy1leHRlcm5hbC1pdGVtLXJlcXVlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLG1DQUFtQztJQUdsQjtJQUY1QixNQUFNLENBQVUsTUFBTSxHQUFHLE1BQU0sQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFDO0lBRXZFLFlBQTRCLEtBQVk7UUFBWixVQUFLLEdBQUwsS0FBSyxDQUFPO0lBQUcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBQcmV2ZW50RGVmYXVsdElzRXh0ZXJuYWxJdGVtUmVxdWVzdCB7XG4gIHN0YXRpYyByZWFkb25seSBmVG9rZW4gPSBTeW1ib2woJ1ByZXZlbnREZWZhdWx0SXNFeHRlcm5hbEl0ZW1SZXF1ZXN0Jyk7XG5cbiAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IGV2ZW50OiBFdmVudCkge31cbn1cbiJdfQ==

package/esm2022/f-draggable/drag-external-item/prevent-default-is-external-item/prevent-default-is-external-item.mjs

@@ -0,0 +1,38 @@
+import { __decorate } from "tslib";
+import { PreventDefaultIsExternalItemRequest } from './prevent-default-is-external-item-request';
+import { FExecutionRegister } from '@foblex/mediator';
+import { Injectable } from '@angular/core';
+import { isExternalItem } from '../../../f-external-item';
+import * as i0 from "@angular/core";
+let PreventDefaultIsExternalItem = class PreventDefaultIsExternalItem {
+    handle(request) {
+        if (!this._isTargetItemExternal(request.event)) {
+            return;
+        }
+        request.event.preventDefault();
+    }
+    _isTargetItemExternal(event) {
+        const isTargetItemExternal = this._isExternalItem(event.target);
+        const isTargetParentItemExternal = this._isExternalItem(event.target.parentNode);
+        return isTargetItemExternal || isTargetParentItemExternal;
+    }
+    _isExternalItem(target) {
+        let result = false;
+        try {
+            result = isExternalItem(target);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) { }
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PreventDefaultIsExternalItem, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PreventDefaultIsExternalItem });
+};
+PreventDefaultIsExternalItem = __decorate([
+    FExecutionRegister(PreventDefaultIsExternalItemRequest)
+], PreventDefaultIsExternalItem);
+export { PreventDefaultIsExternalItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PreventDefaultIsExternalItem, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/drag-external-item/providers.mjs

@@ -0,0 +1,13 @@
+import { PreventDefaultIsExternalItem } from './prevent-default-is-external-item';
+import { DragExternalItemCreatePlaceholder } from './drag-external-item-create-placeholder';
+import { DragExternalItemCreatePreview } from './drag-external-item-create-preview';
+import { DragExternalItemFinalize } from './drag-external-item-finalize';
+import { DragExternalItemPreparation } from './drag-external-item-preparation';
+export const DRAG_EXTERNAL_ITEM_PROVIDERS = [
+    DragExternalItemCreatePlaceholder,
+    DragExternalItemCreatePreview,
+    DragExternalItemFinalize,
+    DragExternalItemPreparation,
+    PreventDefaultIsExternalItem,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9kcmFnLWV4dGVybmFsLWl0ZW0vcHJvdmlkZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ2xGLE9BQU8sRUFBRSxpQ0FBaUMsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQzVGLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQ3BGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3pFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRS9FLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUFHO0lBQzFDLGlDQUFpQztJQUVqQyw2QkFBNkI7SUFFN0Isd0JBQXdCO0lBRXhCLDJCQUEyQjtJQUUzQiw0QkFBNEI7Q0FDN0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFByZXZlbnREZWZhdWx0SXNFeHRlcm5hbEl0ZW0gfSBmcm9tICcuL3ByZXZlbnQtZGVmYXVsdC1pcy1leHRlcm5hbC1pdGVtJztcbmltcG9ydCB7IERyYWdFeHRlcm5hbEl0ZW1DcmVhdGVQbGFjZWhvbGRlciB9IGZyb20gJy4vZHJhZy1leHRlcm5hbC1pdGVtLWNyZWF0ZS1wbGFjZWhvbGRlcic7XG5pbXBvcnQgeyBEcmFnRXh0ZXJuYWxJdGVtQ3JlYXRlUHJldmlldyB9IGZyb20gJy4vZHJhZy1leHRlcm5hbC1pdGVtLWNyZWF0ZS1wcmV2aWV3JztcbmltcG9ydCB7IERyYWdFeHRlcm5hbEl0ZW1GaW5hbGl6ZSB9IGZyb20gJy4vZHJhZy1leHRlcm5hbC1pdGVtLWZpbmFsaXplJztcbmltcG9ydCB7IERyYWdFeHRlcm5hbEl0ZW1QcmVwYXJhdGlvbiB9IGZyb20gJy4vZHJhZy1leHRlcm5hbC1pdGVtLXByZXBhcmF0aW9uJztcblxuZXhwb3J0IGNvbnN0IERSQUdfRVhURVJOQUxfSVRFTV9QUk9WSURFUlMgPSBbXG4gIERyYWdFeHRlcm5hbEl0ZW1DcmVhdGVQbGFjZWhvbGRlcixcblxuICBEcmFnRXh0ZXJuYWxJdGVtQ3JlYXRlUHJldmlldyxcblxuICBEcmFnRXh0ZXJuYWxJdGVtRmluYWxpemUsXG5cbiAgRHJhZ0V4dGVybmFsSXRlbVByZXBhcmF0aW9uLFxuXG4gIFByZXZlbnREZWZhdWx0SXNFeHRlcm5hbEl0ZW0sXG5dO1xuIl19