@foblex/flow 18.1.2 → 18.2.1

package/esm2022/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/attach-resize-connection-drag-handlers-to-node.mjs

@@ -0,0 +1,99 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { AttachResizeConnectionDragHandlersToNodeRequest } from './attach-resize-connection-drag-handlers-to-node-request';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FComponentsStore } from '../../../../f-storage';
+import { ResizeNodeConnectionBothSidesHandler, ResizeNodeConnectionSourceHandler, ResizeNodeConnectionTargetHandler, } from '../../resize-node-handler';
+import { GetNormalizedElementRectRequest } from '../../../../domain';
+import { DragHandlerInjector } from '../../../infrastructure';
+import { CalculateResizeLimitsRequest } from '../../calculate-resize-limits';
+import * as i0 from "@angular/core";
+let AttachResizeConnectionDragHandlersToNode = class AttachResizeConnectionDragHandlersToNode {
+    _store = inject(FComponentsStore);
+    _mediator = inject(FMediator);
+    _dragInjector = inject(DragHandlerInjector);
+    handle({ handler, nodeOrGroup }) {
+        const softParents = this._readSoftParents(nodeOrGroup);
+        const involvedNodes = [nodeOrGroup, ...softParents];
+        const involvedSourceIds = this._collectSourceConnectorIds(involvedNodes);
+        const involvedTargetIds = this._collectTargetConnectorIds(involvedNodes);
+        const connectionHandlerPool = new Map();
+        handler.setNodeConnectionHandlers(this._buildConnectionHandlersForNode(nodeOrGroup, involvedSourceIds, involvedTargetIds, connectionHandlerPool));
+        handler.setSoftParentConnectionHandlers(softParents.map((parent) => this._buildConnectionHandlersForNode(parent, involvedSourceIds, involvedTargetIds, connectionHandlerPool)));
+    }
+    _readSoftParents(nodeOrGroup) {
+        const baselineRect = this._mediator.execute(new GetNormalizedElementRectRequest(nodeOrGroup.hostElement));
+        const constraints = this._mediator.execute(new CalculateResizeLimitsRequest(nodeOrGroup, baselineRect));
+        return constraints.limits.softLimits.map((x) => x.nodeOrGroup);
+    }
+    _collectSourceConnectorIds(nodes) {
+        const nodeIds = new Set(nodes.map((x) => x.fId()));
+        return new Set(this._store.outputs
+            .getAll()
+            .filter((x) => nodeIds.has(x.fNodeId))
+            .map((x) => x.fId()));
+    }
+    _collectTargetConnectorIds(nodes) {
+        const nodeIds = new Set(nodes.map((x) => x.fId()));
+        return new Set(this._store.inputs
+            .getAll()
+            .filter((x) => nodeIds.has(x.fNodeId))
+            .map((x) => x.fId()));
+    }
+    _buildConnectionHandlersForNode(nodeOrGroup, involvedSourceIds, involvedTargetIds, connectionHandlerPool) {
+        const outputs = this._store.outputs.getAll().filter((x) => x.fNodeId === nodeOrGroup.fId());
+        const inputs = this._store.inputs.getAll().filter((x) => x.fNodeId === nodeOrGroup.fId());
+        if (!outputs.length && !inputs.length) {
+            return { source: [], target: [] };
+        }
+        const outputIds = new Set(outputs.map((x) => x.fId()));
+        const inputIds = new Set(inputs.map((x) => x.fId()));
+        const result = { source: [], target: [] };
+        for (const connection of this._store.connections.getAll()) {
+            const isSource = outputIds.has(connection.fOutputId());
+            const isTarget = inputIds.has(connection.fInputId());
+            if (!isSource && !isTarget) {
+                continue;
+            }
+            const connectionHandler = connectionHandlerPool.get(connection.fId()) ??
+                this._createConnectionHandler(connection, involvedSourceIds, involvedTargetIds);
+            connectionHandlerPool.set(connection.fId(), connectionHandler);
+            if (isSource) {
+                const sourceConnector = this._store.outputs.require(connection.fOutputId());
+                result.source.push({
+                    handler: connectionHandler,
+                    connector: sourceConnector,
+                });
+            }
+            if (isTarget) {
+                const targetConnector = this._store.inputs.require(connection.fInputId());
+                result.target.push({
+                    handler: connectionHandler,
+                    connector: targetConnector,
+                });
+            }
+        }
+        return result;
+    }
+    _createConnectionHandler(connection, involvedSourceIds, involvedTargetIds) {
+        const isSource = involvedSourceIds.has(connection.fOutputId());
+        const isTarget = involvedTargetIds.has(connection.fInputId());
+        const result = isSource && isTarget
+            ? this._dragInjector.createInstance(ResizeNodeConnectionBothSidesHandler)
+            : isSource
+                ? this._dragInjector.createInstance(ResizeNodeConnectionSourceHandler)
+                : this._dragInjector.createInstance(ResizeNodeConnectionTargetHandler);
+        result.initialize(connection);
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachResizeConnectionDragHandlersToNode, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachResizeConnectionDragHandlersToNode });
+};
+AttachResizeConnectionDragHandlersToNode = __decorate([
+    FExecutionRegister(AttachResizeConnectionDragHandlersToNodeRequest)
+], AttachResizeConnectionDragHandlersToNode);
+export { AttachResizeConnectionDragHandlersToNode };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AttachResizeConnectionDragHandlersToNode, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attach-resize-connection-drag-handlers-to-node.js","sourceRoot":"","sources":["../../../../../../../projects/f-flow/src/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/attach-resize-connection-drag-handlers-to-node.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { AttachResizeConnectionDragHandlersToNodeRequest } from './attach-resize-connection-drag-handlers-to-node-request';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FComponentsStore } from '../../../../f-storage';\nimport { FNodeBase } from '../../../../f-node';\nimport { FConnectionBase } from '../../../../f-connection-v2';\nimport {\n  ResizeNodeConnectionBothSidesHandler,\n  ResizeNodeConnectionHandlerBase,\n  ResizeNodeConnectionSourceHandler,\n  ResizeNodeConnectionTargetHandler,\n} from '../../resize-node-handler';\nimport { IRect } from '@foblex/2d';\nimport { GetNormalizedElementRectRequest } from '../../../../domain';\nimport { DragHandlerInjector } from '../../../infrastructure';\nimport { CalculateResizeLimitsRequest } from '../../calculate-resize-limits';\nimport { IResizeNodeConnectionHandlers } from '../../resize-node-handler';\nimport { IResizeConstraint, IResizeLimit } from '../../constraint';\n\n@Injectable()\n@FExecutionRegister(AttachResizeConnectionDragHandlersToNodeRequest)\nexport class AttachResizeConnectionDragHandlersToNode\n  implements IExecution<AttachResizeConnectionDragHandlersToNodeRequest, void>\n{\n  private readonly _store = inject(FComponentsStore);\n  private readonly _mediator = inject(FMediator);\n  private readonly _dragInjector = inject(DragHandlerInjector);\n\n  public handle({ handler, nodeOrGroup }: AttachResizeConnectionDragHandlersToNodeRequest): void {\n    const softParents = this._readSoftParents(nodeOrGroup);\n    const involvedNodes = [nodeOrGroup, ...softParents];\n\n    const involvedSourceIds = this._collectSourceConnectorIds(involvedNodes);\n    const involvedTargetIds = this._collectTargetConnectorIds(involvedNodes);\n    const connectionHandlerPool = new Map<string, ResizeNodeConnectionHandlerBase>();\n\n    handler.setNodeConnectionHandlers(\n      this._buildConnectionHandlersForNode(\n        nodeOrGroup,\n        involvedSourceIds,\n        involvedTargetIds,\n        connectionHandlerPool,\n      ),\n    );\n\n    handler.setSoftParentConnectionHandlers(\n      softParents.map((parent) =>\n        this._buildConnectionHandlersForNode(\n          parent,\n          involvedSourceIds,\n          involvedTargetIds,\n          connectionHandlerPool,\n        ),\n      ),\n    );\n  }\n\n  private _readSoftParents(nodeOrGroup: FNodeBase): FNodeBase[] {\n    const baselineRect = this._mediator.execute<IRect>(\n      new GetNormalizedElementRectRequest(nodeOrGroup.hostElement),\n    );\n    const constraints = this._mediator.execute<IResizeConstraint>(\n      new CalculateResizeLimitsRequest(nodeOrGroup, baselineRect),\n    );\n\n    return constraints.limits.softLimits.map((x: IResizeLimit) => x.nodeOrGroup);\n  }\n\n  private _collectSourceConnectorIds(nodes: FNodeBase[]): Set<string> {\n    const nodeIds = new Set(nodes.map((x) => x.fId()));\n\n    return new Set(\n      this._store.outputs\n        .getAll()\n        .filter((x) => nodeIds.has(x.fNodeId))\n        .map((x) => x.fId()),\n    );\n  }\n\n  private _collectTargetConnectorIds(nodes: FNodeBase[]): Set<string> {\n    const nodeIds = new Set(nodes.map((x) => x.fId()));\n\n    return new Set(\n      this._store.inputs\n        .getAll()\n        .filter((x) => nodeIds.has(x.fNodeId))\n        .map((x) => x.fId()),\n    );\n  }\n\n  private _buildConnectionHandlersForNode(\n    nodeOrGroup: FNodeBase,\n    involvedSourceIds: Set<string>,\n    involvedTargetIds: Set<string>,\n    connectionHandlerPool: Map<string, ResizeNodeConnectionHandlerBase>,\n  ): IResizeNodeConnectionHandlers {\n    const outputs = this._store.outputs.getAll().filter((x) => x.fNodeId === nodeOrGroup.fId());\n    const inputs = this._store.inputs.getAll().filter((x) => x.fNodeId === nodeOrGroup.fId());\n\n    if (!outputs.length && !inputs.length) {\n      return { source: [], target: [] };\n    }\n\n    const outputIds = new Set(outputs.map((x) => x.fId()));\n    const inputIds = new Set(inputs.map((x) => x.fId()));\n\n    const result: IResizeNodeConnectionHandlers = { source: [], target: [] };\n\n    for (const connection of this._store.connections.getAll()) {\n      const isSource = outputIds.has(connection.fOutputId());\n      const isTarget = inputIds.has(connection.fInputId());\n      if (!isSource && !isTarget) {\n        continue;\n      }\n\n      const connectionHandler =\n        connectionHandlerPool.get(connection.fId()) ??\n        this._createConnectionHandler(connection, involvedSourceIds, involvedTargetIds);\n      connectionHandlerPool.set(connection.fId(), connectionHandler);\n\n      if (isSource) {\n        const sourceConnector = this._store.outputs.require(connection.fOutputId());\n        result.source.push({\n          handler: connectionHandler,\n          connector: sourceConnector,\n        });\n      }\n\n      if (isTarget) {\n        const targetConnector = this._store.inputs.require(connection.fInputId());\n        result.target.push({\n          handler: connectionHandler,\n          connector: targetConnector,\n        });\n      }\n    }\n\n    return result;\n  }\n\n  private _createConnectionHandler(\n    connection: FConnectionBase,\n    involvedSourceIds: Set<string>,\n    involvedTargetIds: Set<string>,\n  ): ResizeNodeConnectionHandlerBase {\n    const isSource = involvedSourceIds.has(connection.fOutputId());\n    const isTarget = involvedTargetIds.has(connection.fInputId());\n\n    const result =\n      isSource && isTarget\n        ? this._dragInjector.createInstance(ResizeNodeConnectionBothSidesHandler)\n        : isSource\n          ? this._dragInjector.createInstance(ResizeNodeConnectionSourceHandler)\n          : this._dragInjector.createInstance(ResizeNodeConnectionTargetHandler);\n\n    result.initialize(connection);\n\n    return result;\n  }\n}\n"]}

package/esm2022/f-draggable/resize-node/resize-preparation/attach-resize-connection-drag-handlers-to-node/index.mjs

@@ -0,0 +1,3 @@
+export * from './attach-resize-connection-drag-handlers-to-node';
+export * from './attach-resize-connection-drag-handlers-to-node-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3Jlc2l6ZS1ub2RlL3Jlc2l6ZS1wcmVwYXJhdGlvbi9hdHRhY2gtcmVzaXplLWNvbm5lY3Rpb24tZHJhZy1oYW5kbGVycy10by1ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0RBQWtELENBQUM7QUFFakUsY0FBYywwREFBMEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXR0YWNoLXJlc2l6ZS1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vYXR0YWNoLXJlc2l6ZS1jb25uZWN0aW9uLWRyYWctaGFuZGxlcnMtdG8tbm9kZS1yZXF1ZXN0JztcbiJdfQ==

package/esm2022/f-draggable/resize-node/resize-preparation/index.mjs

@@ -0,0 +1,4 @@
+export * from './resize-node-preparation';
+export * from './resize-node-preparation-request';
+export * from './attach-resize-connection-drag-handlers-to-node';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3Jlc2l6ZS1ub2RlL3Jlc2l6ZS1wcmVwYXJhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyxrREFBa0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcmVzaXplLW5vZGUtcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3Jlc2l6ZS1ub2RlLXByZXBhcmF0aW9uLXJlcXVlc3QnO1xuXG5leHBvcnQgKiBmcm9tICcuL2F0dGFjaC1yZXNpemUtY29ubmVjdGlvbi1kcmFnLWhhbmRsZXJzLXRvLW5vZGUnO1xuIl19

package/esm2022/f-draggable/resize-node/resize-preparation/resize-node-preparation-request.mjs

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

package/esm2022/f-draggable/resize-node/resize-preparation/resize-node-preparation.mjs

@@ -0,0 +1,77 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { ResizeNodePreparationRequest } from './resize-node-preparation-request';
+import { Point } from '@foblex/2d';
+import { FExecutionRegister, FMediator } from '@foblex/mediator';
+import { FComponentsStore } from '../../../f-storage';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { isValidEventTrigger, SelectAndUpdateNodeLayerRequest } from '../../../domain';
+import { EFResizeHandleType } from '../../../f-node';
+import { ResizeNodeHandler } from '../resize-node-handler';
+import { getDataAttrValueFromClosestElementWithClass, isClosestElementHasClass, } from '@foblex/utils';
+import { DragHandlerInjector } from '../../infrastructure';
+import { AttachResizeConnectionDragHandlersToNodeRequest } from './attach-resize-connection-drag-handlers-to-node';
+import * as i0 from "@angular/core";
+let ResizeNodePreparation = class ResizeNodePreparation {
+    _mediator = inject(FMediator);
+    _store = inject(FComponentsStore);
+    _dragSession = inject(FDraggableDataContext);
+    _dragInjector = inject(DragHandlerInjector);
+    get _transform() {
+        return this._store.transform;
+    }
+    handle({ event, fTrigger }) {
+        if (!this._dragSession.isEmpty()) {
+            return;
+        }
+        if (!this._isResizeHandle(event.targetElement)) {
+            return;
+        }
+        if (!isValidEventTrigger(event.originalEvent, fTrigger)) {
+            return;
+        }
+        const nodeOrGroup = this._findResizableNode(event.targetElement);
+        if (!nodeOrGroup) {
+            return;
+        }
+        this._selectBeforeResize(nodeOrGroup);
+        const scale = this._transform.scale ?? 1;
+        this._dragSession.onPointerDownScale = scale;
+        this._dragSession.onPointerDownPosition = Point.fromPoint(event.getPosition())
+            .elementTransform(this._store.flowHost)
+            .div(scale);
+        const handler = this._dragInjector.createInstance(ResizeNodeHandler);
+        handler.initialize(nodeOrGroup, this._readResizeHandleType(event.targetElement));
+        this._mediator.execute(new AttachResizeConnectionDragHandlersToNodeRequest(handler, nodeOrGroup));
+        this._dragSession.draggableItems = [handler];
+    }
+    _isResizeHandle(target) {
+        return isClosestElementHasClass(target, '.f-resize-handle');
+    }
+    _findResizableNode(target) {
+        const nodeOrGroup = this._store.nodes.getAll().find((x) => x.isContains(target));
+        if (!nodeOrGroup) {
+            return undefined;
+        }
+        return nodeOrGroup.fDraggingDisabled() ? undefined : nodeOrGroup;
+    }
+    _selectBeforeResize(nodeOrGroup) {
+        queueMicrotask(() => {
+            this._mediator.execute(new SelectAndUpdateNodeLayerRequest(nodeOrGroup));
+        });
+    }
+    _readResizeHandleType(target) {
+        const key = getDataAttrValueFromClosestElementWithClass(target, 'fResizeHandleType', '.f-resize-handle');
+        return EFResizeHandleType[key];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizeNodePreparation, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizeNodePreparation });
+};
+ResizeNodePreparation = __decorate([
+    FExecutionRegister(ResizeNodePreparationRequest)
+], ResizeNodePreparation);
+export { ResizeNodePreparation };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResizeNodePreparation, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resize-node-preparation.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/resize-node/resize-preparation/resize-node-preparation.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { ResizeNodePreparationRequest } from './resize-node-preparation-request';\nimport { ITransformModel, Point } from '@foblex/2d';\nimport { FExecutionRegister, FMediator, IExecution } from '@foblex/mediator';\nimport { FComponentsStore } from '../../../f-storage';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { isValidEventTrigger, SelectAndUpdateNodeLayerRequest } from '../../../domain';\nimport { EFResizeHandleType, FNodeBase } from '../../../f-node';\nimport { ResizeNodeHandler } from '../resize-node-handler';\nimport {\n  getDataAttrValueFromClosestElementWithClass,\n  isClosestElementHasClass,\n} from '@foblex/utils';\nimport { DragHandlerInjector } from '../../infrastructure';\nimport { AttachResizeConnectionDragHandlersToNodeRequest } from './attach-resize-connection-drag-handlers-to-node';\n\n@Injectable()\n@FExecutionRegister(ResizeNodePreparationRequest)\nexport class ResizeNodePreparation implements IExecution<ResizeNodePreparationRequest, void> {\n  private readonly _mediator = inject(FMediator);\n  private readonly _store = inject(FComponentsStore);\n  private readonly _dragSession = inject(FDraggableDataContext);\n  private readonly _dragInjector = inject(DragHandlerInjector);\n\n  private get _transform(): ITransformModel {\n    return this._store.transform;\n  }\n\n  public handle({ event, fTrigger }: ResizeNodePreparationRequest): void {\n    if (!this._dragSession.isEmpty()) {\n      return;\n    }\n\n    if (!this._isResizeHandle(event.targetElement)) {\n      return;\n    }\n\n    if (!isValidEventTrigger(event.originalEvent, fTrigger)) {\n      return;\n    }\n\n    const nodeOrGroup = this._findResizableNode(event.targetElement);\n    if (!nodeOrGroup) {\n      return;\n    }\n\n    this._selectBeforeResize(nodeOrGroup);\n\n    const scale = this._transform.scale ?? 1;\n    this._dragSession.onPointerDownScale = scale;\n    this._dragSession.onPointerDownPosition = Point.fromPoint(event.getPosition())\n      .elementTransform(this._store.flowHost)\n      .div(scale);\n\n    const handler = this._dragInjector.createInstance(ResizeNodeHandler);\n    handler.initialize(nodeOrGroup, this._readResizeHandleType(event.targetElement));\n    this._mediator.execute<void>(\n      new AttachResizeConnectionDragHandlersToNodeRequest(handler, nodeOrGroup),\n    );\n\n    this._dragSession.draggableItems = [handler];\n  }\n\n  private _isResizeHandle(target: HTMLElement): boolean {\n    return isClosestElementHasClass(target, '.f-resize-handle');\n  }\n\n  private _findResizableNode(target: HTMLElement): FNodeBase | undefined {\n    const nodeOrGroup = this._store.nodes.getAll().find((x) => x.isContains(target));\n    if (!nodeOrGroup) {\n      return undefined;\n    }\n\n    return nodeOrGroup.fDraggingDisabled() ? undefined : nodeOrGroup;\n  }\n\n  private _selectBeforeResize(nodeOrGroup: FNodeBase): void {\n    queueMicrotask(() => {\n      this._mediator.execute<void>(new SelectAndUpdateNodeLayerRequest(nodeOrGroup));\n    });\n  }\n\n  private _readResizeHandleType(target: HTMLElement): EFResizeHandleType {\n    const key = getDataAttrValueFromClosestElementWithClass(\n      target,\n      'fResizeHandleType',\n      '.f-resize-handle',\n    ) as keyof typeof EFResizeHandleType;\n\n    return EFResizeHandleType[key];\n  }\n}\n"]}

package/esm2022/f-draggable/rotate-node/calculate-difference-after-rotation.mjs

@@ -0,0 +1,19 @@
+export function calculateDifferenceAfterRotation(position, rotation, pivot) {
+    const { x: newX, y: newY } = calculatePositionAfterRotation(position, rotation, pivot);
+    const dx = newX - position.x;
+    const dy = newY - position.y;
+    return { x: dx, y: dy };
+}
+export function calculatePositionAfterRotation(position, rotation, pivot) {
+    const translatedX = position.x - pivot.x;
+    const translatedY = position.y - pivot.y;
+    const theta = (rotation * Math.PI) / 180;
+    const cosTheta = Math.cos(theta);
+    const sinTheta = Math.sin(theta);
+    const rotatedX = translatedX * cosTheta - translatedY * sinTheta;
+    const rotatedY = translatedX * sinTheta + translatedY * cosTheta;
+    const newX = rotatedX + pivot.x;
+    const newY = rotatedY + pivot.y;
+    return { x: newX, y: newY };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/f-draggable/rotate-node/f-rotate-node-start-event-data.mjs

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

package/esm2022/f-draggable/rotate-node/index.mjs

@@ -0,0 +1,8 @@
+export * from './rotate-node-finalize';
+export * from './rotate-node-preparation';
+export * from './rotate-node-handler';
+export * from './calculate-difference-after-rotation';
+export * from './f-rotate-node-start-event-data';
+export * from './is-rotate-node-handler';
+export * from './providers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3JvdGF0ZS1ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGNBQWMsdUNBQXVDLENBQUM7QUFFdEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxjQUFjLDBCQUEwQixDQUFDO0FBRXpDLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yb3RhdGUtbm9kZS1maW5hbGl6ZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vcm90YXRlLW5vZGUtcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3JvdGF0ZS1ub2RlLWhhbmRsZXInO1xuXG5leHBvcnQgKiBmcm9tICcuL2NhbGN1bGF0ZS1kaWZmZXJlbmNlLWFmdGVyLXJvdGF0aW9uJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLXJvdGF0ZS1ub2RlLXN0YXJ0LWV2ZW50LWRhdGEnO1xuXG5leHBvcnQgKiBmcm9tICcuL2lzLXJvdGF0ZS1ub2RlLWhhbmRsZXInO1xuXG5leHBvcnQgKiBmcm9tICcuL3Byb3ZpZGVycyc7XG4iXX0=

package/esm2022/f-draggable/rotate-node/is-rotate-node-handler.mjs

@@ -0,0 +1,7 @@
+export const ROTATE_NODE_HANDLER_TYPE = 'node-rotate';
+export const ROTATE_NODE_HANDLER_KIND = 'rotate-node';
+export function isRotateNodeHandler(value) {
+    return (value.getEvent().kind === ROTATE_NODE_HANDLER_KIND ||
+        value.getEvent().fEventType === ROTATE_NODE_HANDLER_TYPE);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtcm90YXRlLW5vZGUtaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2YtZmxvdy9zcmMvZi1kcmFnZ2FibGUvcm90YXRlLW5vZGUvaXMtcm90YXRlLW5vZGUtaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRyxhQUFhLENBQUM7QUFDdEQsTUFBTSxDQUFDLE1BQU0sd0JBQXdCLEdBQUcsYUFBYSxDQUFDO0FBRXRELE1BQU0sVUFBVSxtQkFBbUIsQ0FBQyxLQUErQjtJQUNqRSxPQUFPLENBQ0wsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLElBQUksS0FBSyx3QkFBd0I7UUFDbEQsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFVBQVUsS0FBSyx3QkFBd0IsQ0FDekQsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEcmFnSGFuZGxlckJhc2UgfSBmcm9tICcuLi9pbmZyYXN0cnVjdHVyZSc7XG5pbXBvcnQgeyBSb3RhdGVOb2RlSGFuZGxlciB9IGZyb20gJy4vcm90YXRlLW5vZGUtaGFuZGxlcic7XG5cbmV4cG9ydCBjb25zdCBST1RBVEVfTk9ERV9IQU5ETEVSX1RZUEUgPSAnbm9kZS1yb3RhdGUnO1xuZXhwb3J0IGNvbnN0IFJPVEFURV9OT0RFX0hBTkRMRVJfS0lORCA9ICdyb3RhdGUtbm9kZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBpc1JvdGF0ZU5vZGVIYW5kbGVyKHZhbHVlOiBEcmFnSGFuZGxlckJhc2U8dW5rbm93bj4pOiB2YWx1ZSBpcyBSb3RhdGVOb2RlSGFuZGxlciB7XG4gIHJldHVybiAoXG4gICAgdmFsdWUuZ2V0RXZlbnQoKS5raW5kID09PSBST1RBVEVfTk9ERV9IQU5ETEVSX0tJTkQgfHxcbiAgICB2YWx1ZS5nZXRFdmVudCgpLmZFdmVudFR5cGUgPT09IFJPVEFURV9OT0RFX0hBTkRMRVJfVFlQRVxuICApO1xufVxuIl19

package/esm2022/f-draggable/rotate-node/providers.mjs

@@ -0,0 +1,4 @@
+import { RotateNodeFinalize } from './rotate-node-finalize';
+import { RotateNodePreparation } from './rotate-node-preparation';
+export const NODE_ROTATE_PROVIDERS = [RotateNodeFinalize, RotateNodePreparation];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZi1mbG93L3NyYy9mLWRyYWdnYWJsZS9yb3RhdGUtbm9kZS9wcm92aWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDNUQsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFbEUsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsQ0FBQyxrQkFBa0IsRUFBRSxxQkFBcUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUm90YXRlTm9kZUZpbmFsaXplIH0gZnJvbSAnLi9yb3RhdGUtbm9kZS1maW5hbGl6ZSc7XG5pbXBvcnQgeyBSb3RhdGVOb2RlUHJlcGFyYXRpb24gfSBmcm9tICcuL3JvdGF0ZS1ub2RlLXByZXBhcmF0aW9uJztcblxuZXhwb3J0IGNvbnN0IE5PREVfUk9UQVRFX1BST1ZJREVSUyA9IFtSb3RhdGVOb2RlRmluYWxpemUsIFJvdGF0ZU5vZGVQcmVwYXJhdGlvbl07XG4iXX0=

package/esm2022/f-draggable/rotate-node/rotate-node-finalize/index.mjs

@@ -0,0 +1,3 @@
+export * from './rotate-node-finalize';
+export * from './rotate-node-finalize-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3JvdGF0ZS1ub2RlL3JvdGF0ZS1ub2RlLWZpbmFsaXplL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcm90YXRlLW5vZGUtZmluYWxpemUnO1xuXG5leHBvcnQgKiBmcm9tICcuL3JvdGF0ZS1ub2RlLWZpbmFsaXplLXJlcXVlc3QnO1xuIl19

package/esm2022/f-draggable/rotate-node/rotate-node-finalize/rotate-node-finalize-request.mjs

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

package/esm2022/f-draggable/rotate-node/rotate-node-finalize/rotate-node-finalize.mjs

@@ -0,0 +1,31 @@
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { RotateNodeFinalizeRequest } from './rotate-node-finalize-request';
+import { FExecutionRegister } from '@foblex/mediator';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { isRotateNodeHandler } from '../is-rotate-node-handler';
+import * as i0 from "@angular/core";
+let RotateNodeFinalize = class RotateNodeFinalize {
+    _dragSession = inject(FDraggableDataContext);
+    handle(_request) {
+        if (!this._isValid()) {
+            return;
+        }
+        this._dragSession.draggableItems.forEach((x) => {
+            x.onPointerUp?.();
+        });
+    }
+    _isValid() {
+        return this._dragSession.draggableItems.some((x) => isRotateNodeHandler(x));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RotateNodeFinalize, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RotateNodeFinalize });
+};
+RotateNodeFinalize = __decorate([
+    FExecutionRegister(RotateNodeFinalizeRequest)
+], RotateNodeFinalize);
+export { RotateNodeFinalize };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RotateNodeFinalize, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm90YXRlLW5vZGUtZmluYWxpemUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3JvdGF0ZS1ub2RlL3JvdGF0ZS1ub2RlLWZpbmFsaXplL3JvdGF0ZS1ub2RlLWZpbmFsaXplLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUMzRSxPQUFPLEVBQUUsa0JBQWtCLEVBQWMsTUFBTSxrQkFBa0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQzs7QUFJekQsSUFBTSxrQkFBa0IsR0FBeEIsTUFBTSxrQkFBa0I7SUFDWixZQUFZLEdBQUcsTUFBTSxDQUFDLHFCQUFxQixDQUFDLENBQUM7SUFFdkQsTUFBTSxDQUFDLFFBQW1DO1FBQy9DLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQztZQUNyQixPQUFPO1FBQ1QsQ0FBQztRQUNELElBQUksQ0FBQyxZQUFZLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO1lBQzdDLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDO1FBQ3BCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLFFBQVE7UUFDZCxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM5RSxDQUFDO3dHQWRVLGtCQUFrQjs0R0FBbEIsa0JBQWtCOztBQUFsQixrQkFBa0I7SUFEOUIsa0JBQWtCLENBQUMseUJBQXlCLENBQUM7R0FDakMsa0JBQWtCLENBZTlCOzs0RkFmWSxrQkFBa0I7a0JBRjlCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJvdGF0ZU5vZGVGaW5hbGl6ZVJlcXVlc3QgfSBmcm9tICcuL3JvdGF0ZS1ub2RlLWZpbmFsaXplLXJlcXVlc3QnO1xuaW1wb3J0IHsgRkV4ZWN1dGlvblJlZ2lzdGVyLCBJRXhlY3V0aW9uIH0gZnJvbSAnQGZvYmxleC9tZWRpYXRvcic7XG5pbXBvcnQgeyBGRHJhZ2dhYmxlRGF0YUNvbnRleHQgfSBmcm9tICcuLi8uLi9mLWRyYWdnYWJsZS1kYXRhLWNvbnRleHQnO1xuaW1wb3J0IHsgaXNSb3RhdGVOb2RlSGFuZGxlciB9IGZyb20gJy4uL2lzLXJvdGF0ZS1ub2RlLWhhbmRsZXInO1xuXG5ASW5qZWN0YWJsZSgpXG5ARkV4ZWN1dGlvblJlZ2lzdGVyKFJvdGF0ZU5vZGVGaW5hbGl6ZVJlcXVlc3QpXG5leHBvcnQgY2xhc3MgUm90YXRlTm9kZUZpbmFsaXplIGltcGxlbWVudHMgSUV4ZWN1dGlvbjxSb3RhdGVOb2RlRmluYWxpemVSZXF1ZXN0LCB2b2lkPiB7XG4gIHByaXZhdGUgcmVhZG9ubHkgX2RyYWdTZXNzaW9uID0gaW5qZWN0KEZEcmFnZ2FibGVEYXRhQ29udGV4dCk7XG5cbiAgcHVibGljIGhhbmRsZShfcmVxdWVzdDogUm90YXRlTm9kZUZpbmFsaXplUmVxdWVzdCk6IHZvaWQge1xuICAgIGlmICghdGhpcy5faXNWYWxpZCgpKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIHRoaXMuX2RyYWdTZXNzaW9uLmRyYWdnYWJsZUl0ZW1zLmZvckVhY2goKHgpID0+IHtcbiAgICAgIHgub25Qb2ludGVyVXA/LigpO1xuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBfaXNWYWxpZCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5fZHJhZ1Nlc3Npb24uZHJhZ2dhYmxlSXRlbXMuc29tZSgoeCkgPT4gaXNSb3RhdGVOb2RlSGFuZGxlcih4KSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/f-draggable/rotate-node/rotate-node-handler/index.mjs

@@ -0,0 +1,2 @@
+export * from './rotate-node-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3JvdGF0ZS1ub2RlL3JvdGF0ZS1ub2RlLWhhbmRsZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcm90YXRlLW5vZGUtaGFuZGxlcic7XG4iXX0=

package/esm2022/f-draggable/rotate-node/rotate-node-handler/rotate-node-handler.mjs

@@ -0,0 +1,89 @@
+import { PointExtensions } from '@foblex/2d';
+import { DragHandlerBase } from '../../infrastructure';
+import { FRotateNodeStartEventData } from '../f-rotate-node-start-event-data';
+import { FComponentsStore } from '../../../f-storage';
+import { FMediator } from '@foblex/mediator';
+import { FDraggableDataContext } from '../../f-draggable-data-context';
+import { inject, Injectable } from '@angular/core';
+import { GetNormalizedElementRectRequest } from '../../../domain';
+import { calculateDifferenceAfterRotation } from '../calculate-difference-after-rotation';
+import { ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE } from '../is-rotate-node-handler';
+import * as i0 from "@angular/core";
+export class RotateNodeHandler extends DragHandlerBase {
+    type = ROTATE_NODE_HANDLER_TYPE;
+    kind = ROTATE_NODE_HANDLER_KIND;
+    data() {
+        return new FRotateNodeStartEventData(this._nodeOrGroup.fId());
+    }
+    _store = inject(FComponentsStore);
+    _mediator = inject(FMediator);
+    _dragSession = inject(FDraggableDataContext);
+    _nodeOrGroup;
+    _sourceConnections;
+    _targetConnections;
+    _startRotation = 0;
+    _nodeRect;
+    _nodeCenter;
+    _pointerDownInFlow;
+    /**
+     * Difference between pointer angle and node rotation at pointer-down.
+     * This lets us keep rotation “locked” to the initial grab angle.
+     */
+    _rotationOffsetDeg = 0;
+    get _transform() {
+        return this._store.transform;
+    }
+    initialize(nodeOrGroup, sourceConnections, targetConnections) {
+        this._nodeOrGroup = nodeOrGroup;
+        this._sourceConnections = sourceConnections;
+        this._targetConnections = targetConnections;
+        this._startRotation = this._nodeOrGroup._rotate;
+    }
+    prepareDragSequence() {
+        this._nodeRect = this._readNodeRect();
+        this._nodeCenter = this._nodeRect.gravityCenter;
+        this._pointerDownInFlow = this._calculatePointerDownInFlow();
+        const pointerAngleDeg = this._angleDeg(this._pointerDownInFlow);
+        // pointerAngle - nodeRotation => offset
+        this._rotationOffsetDeg = pointerAngleDeg - this._startRotation;
+    }
+    onPointerMove(delta) {
+        const pointerPos = PointExtensions.sum(this._pointerDownInFlow, delta);
+        const pointerAngleDeg = this._angleDeg(pointerPos);
+        const nextRotation = pointerAngleDeg - this._rotationOffsetDeg;
+        this._applyRotation(nextRotation);
+        const rotationDelta = nextRotation - this._startRotation;
+        for (const h of this._sourceConnections) {
+            h.connection.setSourceDelta(this._deltaAfterRotation(h.connector, rotationDelta));
+        }
+        for (const h of this._targetConnections) {
+            h.connection.setTargetDelta(this._deltaAfterRotation(h.connector, rotationDelta));
+        }
+    }
+    onPointerUp() {
+        this._nodeOrGroup.rotate.set(this._nodeOrGroup._rotate);
+        this._nodeOrGroup.refresh();
+    }
+    _readNodeRect() {
+        return this._mediator.execute(new GetNormalizedElementRectRequest(this._nodeOrGroup.hostElement));
+    }
+    _calculatePointerDownInFlow() {
+        return PointExtensions.sub(this._dragSession.onPointerDownPosition, PointExtensions.sum(this._transform.position, this._transform.scaledPosition));
+    }
+    _angleDeg(p) {
+        return Math.atan2(p.y - this._nodeCenter.y, p.x - this._nodeCenter.x) * (180 / Math.PI);
+    }
+    _applyRotation(rotationDeg) {
+        this._nodeOrGroup.updateRotate(rotationDeg);
+        this._nodeOrGroup.redraw();
+    }
+    _deltaAfterRotation(connector, rotationDeltaDeg) {
+        return calculateDifferenceAfterRotation(connector, rotationDeltaDeg, this._nodeCenter);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RotateNodeHandler, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RotateNodeHandler });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RotateNodeHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rotate-node-handler.js","sourceRoot":"","sources":["../../../../../../projects/f-flow/src/f-draggable/rotate-node/rotate-node-handler/rotate-node-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { IPoint, IRect, ITransformModel, PointExtensions } from '@foblex/2d';\nimport { DragHandlerBase } from '../../infrastructure';\nimport { FRotateNodeStartEventData } from '../f-rotate-node-start-event-data';\nimport { FComponentsStore } from '../../../f-storage';\nimport { FMediator } from '@foblex/mediator';\nimport { FDraggableDataContext } from '../../f-draggable-data-context';\nimport { inject, Injectable } from '@angular/core';\nimport { FNodeBase } from '../../../f-node';\nimport { DragNodeConnectionHandlerBase } from '../../drag-node';\nimport { GetNormalizedElementRectRequest } from '../../../domain';\nimport { calculateDifferenceAfterRotation } from '../calculate-difference-after-rotation';\nimport { ROTATE_NODE_HANDLER_KIND, ROTATE_NODE_HANDLER_TYPE } from '../is-rotate-node-handler';\n\ntype TRotateConnectionHandler = {\n  connection: DragNodeConnectionHandlerBase;\n  connector: IPoint;\n};\n\n@Injectable()\nexport class RotateNodeHandler extends DragHandlerBase<FRotateNodeStartEventData> {\n  protected readonly type = ROTATE_NODE_HANDLER_TYPE;\n  protected readonly kind = ROTATE_NODE_HANDLER_KIND;\n\n  protected override data() {\n    return new FRotateNodeStartEventData(this._nodeOrGroup.fId());\n  }\n\n  private readonly _store = inject(FComponentsStore);\n  private readonly _mediator = inject(FMediator);\n  private readonly _dragSession = inject(FDraggableDataContext);\n\n  private _nodeOrGroup!: FNodeBase;\n  private _sourceConnections!: TRotateConnectionHandler[];\n  private _targetConnections!: TRotateConnectionHandler[];\n\n  private _startRotation: number = 0;\n\n  private _nodeRect!: IRect;\n  private _nodeCenter!: IPoint;\n\n  private _pointerDownInFlow!: IPoint;\n\n  /**\n   * Difference between pointer angle and node rotation at pointer-down.\n   * This lets us keep rotation “locked” to the initial grab angle.\n   */\n  private _rotationOffsetDeg = 0;\n\n  private get _transform(): ITransformModel {\n    return this._store.transform;\n  }\n\n  public initialize(\n    nodeOrGroup: FNodeBase,\n    sourceConnections: TRotateConnectionHandler[],\n    targetConnections: TRotateConnectionHandler[],\n  ): void {\n    this._nodeOrGroup = nodeOrGroup;\n    this._sourceConnections = sourceConnections;\n    this._targetConnections = targetConnections;\n\n    this._startRotation = this._nodeOrGroup._rotate;\n  }\n\n  public override prepareDragSequence(): void {\n    this._nodeRect = this._readNodeRect();\n    this._nodeCenter = this._nodeRect.gravityCenter;\n\n    this._pointerDownInFlow = this._calculatePointerDownInFlow();\n    const pointerAngleDeg = this._angleDeg(this._pointerDownInFlow);\n\n    // pointerAngle - nodeRotation => offset\n    this._rotationOffsetDeg = pointerAngleDeg - this._startRotation;\n  }\n\n  public onPointerMove(delta: IPoint): void {\n    const pointerPos = PointExtensions.sum(this._pointerDownInFlow, delta);\n    const pointerAngleDeg = this._angleDeg(pointerPos);\n\n    const nextRotation = pointerAngleDeg - this._rotationOffsetDeg;\n    this._applyRotation(nextRotation);\n\n    const rotationDelta = nextRotation - this._startRotation;\n\n    for (const h of this._sourceConnections) {\n      h.connection.setSourceDelta(this._deltaAfterRotation(h.connector, rotationDelta));\n    }\n\n    for (const h of this._targetConnections) {\n      h.connection.setTargetDelta(this._deltaAfterRotation(h.connector, rotationDelta));\n    }\n  }\n\n  public override onPointerUp(): void {\n    this._nodeOrGroup.rotate.set(this._nodeOrGroup._rotate);\n    this._nodeOrGroup.refresh();\n  }\n\n  private _readNodeRect(): IRect {\n    return this._mediator.execute<IRect>(\n      new GetNormalizedElementRectRequest(this._nodeOrGroup.hostElement),\n    );\n  }\n\n  private _calculatePointerDownInFlow(): IPoint {\n    return PointExtensions.sub(\n      this._dragSession.onPointerDownPosition,\n      PointExtensions.sum(this._transform.position, this._transform.scaledPosition),\n    );\n  }\n\n  private _angleDeg(p: IPoint): number {\n    return Math.atan2(p.y - this._nodeCenter.y, p.x - this._nodeCenter.x) * (180 / Math.PI);\n  }\n\n  private _applyRotation(rotationDeg: number): void {\n    this._nodeOrGroup.updateRotate(rotationDeg);\n    this._nodeOrGroup.redraw();\n  }\n\n  private _deltaAfterRotation(connector: IPoint, rotationDeltaDeg: number): IPoint {\n    return calculateDifferenceAfterRotation(connector, rotationDeltaDeg, this._nodeCenter);\n  }\n}\n"]}

package/esm2022/f-draggable/rotate-node/rotate-node-preparation/index.mjs

@@ -0,0 +1,3 @@
+export * from './rotate-node-preparation';
+export * from './rotate-node-preparation-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9mLWZsb3cvc3JjL2YtZHJhZ2dhYmxlL3JvdGF0ZS1ub2RlL3JvdGF0ZS1ub2RlLXByZXBhcmF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMkJBQTJCLENBQUM7QUFFMUMsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcm90YXRlLW5vZGUtcHJlcGFyYXRpb24nO1xuXG5leHBvcnQgKiBmcm9tICcuL3JvdGF0ZS1ub2RlLXByZXBhcmF0aW9uLXJlcXVlc3QnO1xuIl19

package/esm2022/f-draggable/rotate-node/rotate-node-preparation/rotate-node-preparation-request.mjs

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