@uipath/apollo-react 6.10.0 → 6.11.1

package/dist/canvas/components/AlignmentGuides/AlignmentGuides.types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/AlignmentGuides/AlignmentGuides.types.d.ts

@@ -0,0 +1,21 @@
+export type AlignmentGuideOrientation = 'vertical' | 'horizontal';
+export type AlignmentGuideKind = 'edge' | 'center';
+export interface AlignmentGuideLine {
+    id: string;
+    orientation: AlignmentGuideOrientation;
+    position: number;
+    start: number;
+    end: number;
+    kind: AlignmentGuideKind;
+    matchedNodeIds: string[];
+}
+export interface NodeBounds {
+    id: string;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    cx: number;
+    cy: number;
+}
+//# sourceMappingURL=AlignmentGuides.types.d.ts.map

package/dist/canvas/components/AlignmentGuides/AlignmentGuides.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlignmentGuides.types.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/AlignmentGuides/AlignmentGuides.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG,UAAU,GAAG,YAAY,CAAC;AAGlE,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAOnD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,yBAAyB,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IAEZ,IAAI,EAAE,kBAAkB,CAAC;IAEzB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ"}

package/dist/canvas/components/AlignmentGuides/AlignmentGuidesOverlay.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AlignmentGuidesOverlay: ()=>AlignmentGuidesOverlay
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const react_cjs_namespaceObject = require("../../xyflow/react.cjs");
+function AlignmentGuidesOverlay({ guides, draggedBounds }) {
+    const { x: viewportX, y: viewportY, zoom } = (0, react_cjs_namespaceObject.useViewport)();
+    if (0 === guides.length && !draggedBounds) return null;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+        className: "pointer-events-none absolute inset-0 z-40 overflow-hidden",
+        children: [
+            guides.map((guide)=>{
+                const isVertical = 'vertical' === guide.orientation;
+                const style = isVertical ? {
+                    left: guide.position * zoom + viewportX,
+                    top: guide.start * zoom + viewportY,
+                    height: (guide.end - guide.start) * zoom
+                } : {
+                    top: guide.position * zoom + viewportY,
+                    left: guide.start * zoom + viewportX,
+                    width: (guide.end - guide.start) * zoom
+                };
+                return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                    className: isVertical ? 'absolute border-l border-dashed' : 'absolute border-t border-dashed',
+                    style: {
+                        ...style,
+                        borderColor: 'var(--canvas-selection-indicator)'
+                    }
+                }, guide.id);
+            }),
+            draggedBounds && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                className: "absolute rounded-md border border-dashed",
+                style: {
+                    left: draggedBounds.x1 * zoom + viewportX - 8,
+                    top: draggedBounds.y1 * zoom + viewportY - 8,
+                    width: (draggedBounds.x2 - draggedBounds.x1) * zoom + 16,
+                    height: (draggedBounds.y2 - draggedBounds.y1) * zoom + 16,
+                    borderColor: 'var(--canvas-selection-indicator)'
+                }
+            })
+        ]
+    });
+}
+exports.AlignmentGuidesOverlay = __webpack_exports__.AlignmentGuidesOverlay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AlignmentGuidesOverlay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/AlignmentGuides/AlignmentGuidesOverlay.d.ts

@@ -0,0 +1,7 @@
+import type { AlignmentGuideLine, NodeBounds } from './AlignmentGuides.types';
+export interface AlignmentGuidesOverlayProps {
+    guides: AlignmentGuideLine[];
+    draggedBounds?: NodeBounds | null;
+}
+export declare function AlignmentGuidesOverlay({ guides, draggedBounds }: AlignmentGuidesOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=AlignmentGuidesOverlay.d.ts.map

package/dist/canvas/components/AlignmentGuides/AlignmentGuidesOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlignmentGuidesOverlay.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/AlignmentGuides/AlignmentGuidesOverlay.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE9E,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAE7B,aAAa,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CACnC;AAOD,wBAAgB,sBAAsB,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,2BAA2B,kDA6C5F"}

package/dist/canvas/components/AlignmentGuides/AlignmentGuidesOverlay.js

@@ -0,0 +1,41 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useViewport } from "../../xyflow/react.js";
+function AlignmentGuidesOverlay({ guides, draggedBounds }) {
+    const { x: viewportX, y: viewportY, zoom } = useViewport();
+    if (0 === guides.length && !draggedBounds) return null;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "pointer-events-none absolute inset-0 z-40 overflow-hidden",
+        children: [
+            guides.map((guide)=>{
+                const isVertical = 'vertical' === guide.orientation;
+                const style = isVertical ? {
+                    left: guide.position * zoom + viewportX,
+                    top: guide.start * zoom + viewportY,
+                    height: (guide.end - guide.start) * zoom
+                } : {
+                    top: guide.position * zoom + viewportY,
+                    left: guide.start * zoom + viewportX,
+                    width: (guide.end - guide.start) * zoom
+                };
+                return /*#__PURE__*/ jsx("div", {
+                    className: isVertical ? 'absolute border-l border-dashed' : 'absolute border-t border-dashed',
+                    style: {
+                        ...style,
+                        borderColor: 'var(--canvas-selection-indicator)'
+                    }
+                }, guide.id);
+            }),
+            draggedBounds && /*#__PURE__*/ jsx("div", {
+                className: "absolute rounded-md border border-dashed",
+                style: {
+                    left: draggedBounds.x1 * zoom + viewportX - 8,
+                    top: draggedBounds.y1 * zoom + viewportY - 8,
+                    width: (draggedBounds.x2 - draggedBounds.x1) * zoom + 16,
+                    height: (draggedBounds.y2 - draggedBounds.y1) * zoom + 16,
+                    borderColor: 'var(--canvas-selection-indicator)'
+                }
+            })
+        ]
+    });
+}
+export { AlignmentGuidesOverlay };

package/dist/canvas/components/AlignmentGuides/index.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_modules__ = {
+    "./AlignmentGuides.types" (module) {
+        module.exports = require("./AlignmentGuides.types.cjs");
+    },
+    "./AlignmentGuidesOverlay" (module) {
+        module.exports = require("./AlignmentGuidesOverlay.cjs");
+    },
+    "./useAlignmentGuides" (module) {
+        module.exports = require("./useAlignmentGuides.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _AlignmentGuides_types__rspack_import_0 = __webpack_require__("./AlignmentGuides.types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _AlignmentGuides_types__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_AlignmentGuides_types__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _AlignmentGuidesOverlay__rspack_import_1 = __webpack_require__("./AlignmentGuidesOverlay");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _AlignmentGuidesOverlay__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_AlignmentGuidesOverlay__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _useAlignmentGuides__rspack_import_2 = __webpack_require__("./useAlignmentGuides");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _useAlignmentGuides__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_useAlignmentGuides__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/AlignmentGuides/index.d.ts

@@ -0,0 +1,4 @@
+export * from './AlignmentGuides.types';
+export * from './AlignmentGuidesOverlay';
+export * from './useAlignmentGuides';
+//# sourceMappingURL=index.d.ts.map

package/dist/canvas/components/AlignmentGuides/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/AlignmentGuides/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC"}

package/dist/canvas/components/AlignmentGuides/index.js

@@ -0,0 +1,3 @@
+export * from "./AlignmentGuides.types.js";
+export * from "./AlignmentGuidesOverlay.js";
+export * from "./useAlignmentGuides.js";

package/dist/canvas/components/AlignmentGuides/useAlignmentGuides.cjs

@@ -0,0 +1,256 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createAlignmentPositionUpdates: ()=>createAlignmentPositionUpdates,
+    computeAlignmentResult: ()=>computeAlignmentResult,
+    toBounds: ()=>toBounds,
+    toGroupBounds: ()=>toGroupBounds,
+    useAlignmentGuides: ()=>useAlignmentGuides,
+    computeAlignmentSnapDelta: ()=>computeAlignmentSnapDelta,
+    computeAlignmentGuides: ()=>computeAlignmentGuides
+});
+const react_cjs_namespaceObject = require("../../xyflow/react.cjs");
+const external_react_namespaceObject = require("react");
+const external_constants_cjs_namespaceObject = require("../../constants.cjs");
+const NodeUtils_cjs_namespaceObject = require("../../utils/NodeUtils.cjs");
+function toBounds(node, allNodes = [
+    node
+]) {
+    const width = node.measured?.width ?? node.width ?? external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE;
+    const height = node.measured?.height ?? node.height ?? external_constants_cjs_namespaceObject.DEFAULT_NODE_SIZE;
+    const absolutePosition = node.internals?.positionAbsolute ?? (node.parentId ? (0, NodeUtils_cjs_namespaceObject.getAbsolutePosition)(node, allNodes) : node.position);
+    const x1 = absolutePosition.x;
+    const y1 = absolutePosition.y;
+    const x2 = x1 + width;
+    const y2 = y1 + height;
+    return {
+        id: node.id,
+        x1,
+        y1,
+        x2,
+        y2,
+        cx: (x1 + x2) / 2,
+        cy: (y1 + y2) / 2
+    };
+}
+function getAxisAnchors(bounds, orientation) {
+    return 'vertical' === orientation ? [
+        bounds.x1,
+        bounds.cx,
+        bounds.x2
+    ] : [
+        bounds.y1,
+        bounds.cy,
+        bounds.y2
+    ];
+}
+function resolveAxisCandidate(dragged, others, threshold, orientation) {
+    const draggedAnchors = getAxisAnchors(dragged, orientation);
+    const candidates = [];
+    for (const other of others){
+        const otherAnchors = getAxisAnchors(other, orientation);
+        candidates.push({
+            delta: otherAnchors[1] - draggedAnchors[1],
+            kind: 'center',
+            matchedNodeId: other.id,
+            position: otherAnchors[1],
+            priority: 0
+        });
+        for (const draggedIndex of [
+            0,
+            2
+        ])for (const otherIndex of [
+            0,
+            2
+        ])candidates.push({
+            delta: otherAnchors[otherIndex] - draggedAnchors[draggedIndex],
+            kind: 'edge',
+            matchedNodeId: other.id,
+            position: otherAnchors[otherIndex],
+            priority: draggedIndex === otherIndex ? 1 : 2
+        });
+    }
+    return candidates.filter(({ delta })=>Math.abs(delta) <= threshold).sort((a, b)=>Math.abs(a.delta) - Math.abs(b.delta) || a.priority - b.priority || a.position - b.position || a.matchedNodeId.localeCompare(b.matchedNodeId))[0];
+}
+function buildGuide(candidate, dragged, others, orientation) {
+    const matchingOthers = others.filter((other)=>{
+        const anchors = getAxisAnchors(other, orientation);
+        const candidateAnchors = 'center' === candidate.kind ? [
+            anchors[1]
+        ] : [
+            anchors[0],
+            anchors[2]
+        ];
+        return candidateAnchors.some((anchor)=>Math.abs(anchor - candidate.position) < 0.5);
+    });
+    const ranges = [
+        dragged,
+        ...matchingOthers
+    ].map((bounds)=>'vertical' === orientation ? [
+            bounds.y1,
+            bounds.y2
+        ] : [
+            bounds.x1,
+            bounds.x2
+        ]);
+    return {
+        id: `${orientation}-${candidate.position}`,
+        orientation,
+        position: candidate.position,
+        start: Math.min(...ranges.map(([rangeStart])=>rangeStart)),
+        end: Math.max(...ranges.map(([, rangeEnd])=>rangeEnd)),
+        kind: candidate.kind,
+        matchedNodeIds: matchingOthers.map(({ id })=>id)
+    };
+}
+function computeAlignmentResult(dragged, others, threshold) {
+    const vertical = resolveAxisCandidate(dragged, others, threshold, 'vertical');
+    const horizontal = resolveAxisCandidate(dragged, others, threshold, 'horizontal');
+    const delta = {
+        dx: vertical?.delta ?? 0,
+        dy: horizontal?.delta ?? 0
+    };
+    const snapped = {
+        ...dragged,
+        x1: dragged.x1 + delta.dx,
+        x2: dragged.x2 + delta.dx,
+        cx: dragged.cx + delta.dx,
+        y1: dragged.y1 + delta.dy,
+        y2: dragged.y2 + delta.dy,
+        cy: dragged.cy + delta.dy
+    };
+    const guides = [
+        ...vertical ? [
+            buildGuide(vertical, snapped, others, 'vertical')
+        ] : [],
+        ...horizontal ? [
+            buildGuide(horizontal, snapped, others, 'horizontal')
+        ] : []
+    ];
+    return {
+        guides,
+        delta
+    };
+}
+function computeAlignmentGuides(dragged, others, threshold) {
+    return computeAlignmentResult(dragged, others, threshold).guides;
+}
+function computeAlignmentSnapDelta(dragged, others, threshold) {
+    return computeAlignmentResult(dragged, others, threshold).delta;
+}
+function toGroupBounds(nodes, allNodes = nodes) {
+    const bounds = nodes.map((node)=>toBounds(node, allNodes));
+    const x1 = Math.min(...bounds.map((item)=>item.x1));
+    const y1 = Math.min(...bounds.map((item)=>item.y1));
+    const x2 = Math.max(...bounds.map((item)=>item.x2));
+    const y2 = Math.max(...bounds.map((item)=>item.y2));
+    return {
+        id: bounds.map(({ id })=>id).join(','),
+        x1,
+        y1,
+        x2,
+        y2,
+        cx: (x1 + x2) / 2,
+        cy: (y1 + y2) / 2
+    };
+}
+function createAlignmentPositionUpdates(nodes, delta) {
+    return nodes.map(({ id, position })=>({
+            id,
+            position: {
+                x: position.x + delta.dx,
+                y: position.y + delta.dy
+            }
+        }));
+}
+function useAlignmentGuides(nodes, options = {}) {
+    const { thresholdPx = 8, onSnap } = options;
+    const { zoom } = (0, react_cjs_namespaceObject.useViewport)();
+    const [guides, setGuides] = (0, external_react_namespaceObject.useState)([]);
+    const [draggedBounds, setDraggedBounds] = (0, external_react_namespaceObject.useState)(null);
+    const resolveDrag = (0, external_react_namespaceObject.useCallback)((draggedNode, draggedNodes, showGuides)=>{
+        const activeNodes = draggedNodes.length > 0 ? draggedNodes : [
+            draggedNode
+        ];
+        const activeIds = new Set(activeNodes.map(({ id })=>id));
+        const others = nodes.filter(({ id })=>!activeIds.has(id)).map((node)=>toBounds(node, nodes));
+        const activeBounds = toGroupBounds(activeNodes, nodes);
+        const result = computeAlignmentResult(activeBounds, others, thresholdPx / zoom);
+        setDraggedBounds(showGuides ? {
+            ...activeBounds,
+            x1: activeBounds.x1 + result.delta.dx,
+            x2: activeBounds.x2 + result.delta.dx,
+            cx: activeBounds.cx + result.delta.dx,
+            y1: activeBounds.y1 + result.delta.dy,
+            y2: activeBounds.y2 + result.delta.dy,
+            cy: activeBounds.cy + result.delta.dy
+        } : null);
+        setGuides(showGuides ? result.guides : []);
+        if (!onSnap || 0 === result.delta.dx && 0 === result.delta.dy) return;
+        onSnap(createAlignmentPositionUpdates(activeNodes, result.delta));
+    }, [
+        nodes,
+        onSnap,
+        thresholdPx,
+        zoom
+    ]);
+    const onNodeDrag = (0, external_react_namespaceObject.useCallback)((_event, draggedNode, draggedNodes)=>resolveDrag(draggedNode, draggedNodes, true), [
+        resolveDrag
+    ]);
+    const onNodeDragStop = (0, external_react_namespaceObject.useCallback)((_event, draggedNode, draggedNodes)=>resolveDrag(draggedNode, draggedNodes, false), [
+        resolveDrag
+    ]);
+    return (0, external_react_namespaceObject.useMemo)(()=>({
+            guides,
+            draggedBounds,
+            onNodeDrag,
+            onNodeDragStop
+        }), [
+        guides,
+        draggedBounds,
+        onNodeDrag,
+        onNodeDragStop
+    ]);
+}
+exports.computeAlignmentGuides = __webpack_exports__.computeAlignmentGuides;
+exports.computeAlignmentResult = __webpack_exports__.computeAlignmentResult;
+exports.computeAlignmentSnapDelta = __webpack_exports__.computeAlignmentSnapDelta;
+exports.createAlignmentPositionUpdates = __webpack_exports__.createAlignmentPositionUpdates;
+exports.toBounds = __webpack_exports__.toBounds;
+exports.toGroupBounds = __webpack_exports__.toGroupBounds;
+exports.useAlignmentGuides = __webpack_exports__.useAlignmentGuides;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "computeAlignmentGuides",
+    "computeAlignmentResult",
+    "computeAlignmentSnapDelta",
+    "createAlignmentPositionUpdates",
+    "toBounds",
+    "toGroupBounds",
+    "useAlignmentGuides"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/components/AlignmentGuides/useAlignmentGuides.d.ts

@@ -0,0 +1,35 @@
+import type { Node, OnNodeDrag } from '../../xyflow/react.ts';
+import type { AlignmentGuideLine, NodeBounds } from './AlignmentGuides.types';
+export declare function toBounds(node: Node, allNodes?: Node[]): NodeBounds;
+export interface AlignmentSnapDelta {
+    dx: number;
+    dy: number;
+}
+export interface AlignmentResult {
+    guides: AlignmentGuideLine[];
+    delta: AlignmentSnapDelta;
+}
+export declare function computeAlignmentResult(dragged: NodeBounds, others: NodeBounds[], threshold: number): AlignmentResult;
+export declare function computeAlignmentGuides(dragged: NodeBounds, others: NodeBounds[], threshold: number): AlignmentGuideLine[];
+export declare function computeAlignmentSnapDelta(dragged: NodeBounds, others: NodeBounds[], threshold: number): AlignmentSnapDelta;
+export declare function toGroupBounds(nodes: Node[], allNodes?: Node[]): NodeBounds;
+export interface UseAlignmentGuidesOptions {
+    thresholdPx?: number;
+    onSnap?: (updates: AlignmentPositionUpdate[]) => void;
+}
+export interface AlignmentPositionUpdate {
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare function createAlignmentPositionUpdates(nodes: Node[], delta: AlignmentSnapDelta): AlignmentPositionUpdate[];
+export interface UseAlignmentGuidesReturn {
+    guides: AlignmentGuideLine[];
+    draggedBounds: NodeBounds | null;
+    onNodeDrag: OnNodeDrag;
+    onNodeDragStop: OnNodeDrag;
+}
+export declare function useAlignmentGuides(nodes: Node[], options?: UseAlignmentGuidesOptions): UseAlignmentGuidesReturn;
+//# sourceMappingURL=useAlignmentGuides.d.ts.map

package/dist/canvas/components/AlignmentGuides/useAlignmentGuides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAlignmentGuides.d.ts","sourceRoot":"","sources":["../../../../src/canvas/components/AlignmentGuides/useAlignmentGuides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAKjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAM9E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAE,IAAI,EAAW,GAAG,UAAU,CAW1E;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AA+FD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,UAAU,EAAE,EACpB,SAAS,EAAE,MAAM,GAChB,eAAe,CAmBjB;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,UAAU,EAAE,EACpB,SAAS,EAAE,MAAM,GAChB,kBAAkB,EAAE,CAEtB;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,UAAU,EAAE,EACpB,SAAS,EAAE,MAAM,GAChB,kBAAkB,CAEpB;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,QAAQ,GAAE,IAAI,EAAU,GAAG,UAAU,CAejF;AAED,MAAM,WAAW,yBAAyB;IAOxC,WAAW,CAAC,EAAE,MAAM,CAAC;IAMrB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,uBAAuB,EAAE,KAAK,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpC;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,IAAI,EAAE,EACb,KAAK,EAAE,kBAAkB,GACxB,uBAAuB,EAAE,CAK3B;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,aAAa,EAAE,UAAU,GAAG,IAAI,CAAC;IACjC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,UAAU,CAAC;CAC5B;AAUD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,GAAE,yBAA8B,GACtC,wBAAwB,CAkD1B"}