@rsconcept/domain 1.0.0 → 1.1.0

package/dist/library/oss-layout-api.js

@@ -1,330 +1,253 @@
-// src/library/oss.ts
-var NodeType = {
-  OPERATION: 1,
-  BLOCK: 2
-};
-var OperationType = {
-  INPUT: "input",
-  SYNTHESIS: "synthesis",
-  REPLICA: "replica"
-};
-
-// src/library/oss-layout-api.ts
-var GRID_SIZE = 10;
-var MIN_DISTANCE = 2 * GRID_SIZE;
-var OPERATION_NODE_WIDTH = 150;
-var OPERATION_NODE_HEIGHT = 40;
+import { NodeType, OperationType } from "./oss.js";
+//#region src/library/oss-layout-api.ts
+const GRID_SIZE = 10;
+const MIN_DISTANCE = 20;
+const OPERATION_NODE_WIDTH = 150;
+const OPERATION_NODE_HEIGHT = 40;
+/** Layout manipulations for {@link OperationSchema}. */
 var LayoutManager = class {
-  oss;
-  layout;
-  constructor(oss, layout) {
-    this.oss = oss;
-    if (layout) {
-      this.layout = layout;
-    } else {
-      this.layout = this.oss.layout;
-    }
-  }
-  /** Calculate insert position for a new {@link Operation} */
-  newOperationPosition(position, parent, args = []) {
-    const result = { ...position };
-    const parentNode = this.layout.find((pos) => pos.nodeID === `b${parent}`) ?? null;
-    const operations = this.layout.filter((pos) => pos.nodeID.startsWith("o"));
-    const hasArguments = args.length !== 0;
-    if (hasArguments) {
-      const pos = calculatePositionFromArgs(operations.filter((node) => args.includes(Number(node.nodeID.slice(1)))));
-      result.x = pos.x;
-      result.y = pos.y;
-    } else if (parentNode) {
-      result.x = parentNode.x + MIN_DISTANCE;
-      result.y = parentNode.y + MIN_DISTANCE;
-    } else {
-      const pos = this.calculatePositionForFreeOperation(result);
-      result.x = pos.x;
-      result.y = pos.y;
-    }
-    const siblingBlocks = this.oss.blocks.filter((block) => block.parent === parent).map((block) => block.nodeID);
-    preventOverlap(
-      result,
-      this.layout.filter((node) => siblingBlocks.includes(node.nodeID)),
-      {
-        moveX: !hasArguments,
-        moveY: hasArguments
-      }
-    );
-    preventOverlap(result, operations);
-    this.extendParentBounds(parentNode, result);
-    return result;
-  }
-  /** Calculate insert position for a new {@link Block} */
-  newBlockPosition(position, parent, blocks, operations) {
-    const blockNodes = blocks.map((id) => this.layout.find((block) => block.nodeID === `b${id}`)).filter((node) => !!node);
-    const operationNodes = operations.map((id) => this.layout.find((operation) => operation.nodeID === `o${id}`)).filter((node) => !!node);
-    const parentNode = this.layout.find((pos) => pos.nodeID === `b${parent}`) ?? null;
-    const parentID = parentNode ? parent : null;
-    let result = { ...position };
-    if (blockNodes.length !== 0 || operationNodes.length !== 0) {
-      result = calculatePositionFromChildren(position, operationNodes, blockNodes);
-    } else if (parentNode) {
-      result = {
-        x: parentNode.x + MIN_DISTANCE,
-        y: parentNode.y + MIN_DISTANCE,
-        width: position.width,
-        height: position.height
-      };
-    } else {
-      result = this.calculatePositionForFreeBlock(result);
-    }
-    if (blockNodes.length === 0 && operationNodes.length === 0) {
-      const siblings = this.oss.blocks.filter((block) => block.parent === parentID).map((block) => block.nodeID);
-      preventOverlap(
-        result,
-        this.layout.filter((node) => siblings.includes(node.nodeID))
-      );
-    }
-    this.extendParentBounds(parentNode, result);
-    return result;
-  }
-  /** Calculate insert position for a new clone of {@link Operation} */
-  newClonePosition(targetID) {
-    const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
-    if (!targetNode) {
-      return null;
-    } else {
-      return {
-        x: targetNode.x + targetNode.width / 2 + GRID_SIZE,
-        y: targetNode.y + targetNode.height / 2 + GRID_SIZE,
-        width: OPERATION_NODE_WIDTH,
-        height: OPERATION_NODE_HEIGHT
-      };
-    }
-  }
-  /** Update layout when parent changes */
-  onChangeParent(targetID, newParent) {
-    const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
-    if (!targetNode) {
-      return;
-    }
-    const parentNode = this.layout.find((pos) => pos.nodeID === newParent) ?? null;
-    const offset = this.calculateOffsetForParentChange(targetNode, parentNode);
-    if (offset.x === 0 && offset.y === 0) {
-      return;
-    }
-    targetNode.x += offset.x;
-    targetNode.y += offset.y;
-    const children = this.oss.hierarchy.expandAllOutputs([targetID]);
-    const childrenPositions = this.layout.filter((pos) => children.includes(pos.nodeID));
-    for (const child of childrenPositions) {
-      child.x += offset.x;
-      child.y += offset.y;
-    }
-    this.extendParentBounds(parentNode, targetNode);
-  }
-  /** Calculate closest node to the left */
-  selectLeft(targetID) {
-    const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
-    if (!targetNode) {
-      return null;
-    }
-    const operationNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o"));
-    const leftNodes = operationNodes.filter((pos) => pos.x <= targetNode.x);
-    if (leftNodes.length === 0) {
-      return null;
-    }
-    const similarYNodes = leftNodes.filter((pos) => Math.abs(pos.y - targetNode.y) <= MIN_DISTANCE);
-    let closestNode = null;
-    if (similarYNodes.length > 0) {
-      closestNode = similarYNodes.reduce((prev, curr) => curr.x > prev.x ? curr : prev);
-    } else {
-      closestNode = findClosestNodeByDistance(leftNodes, targetNode);
-    }
-    return closestNode?.nodeID ?? null;
-  }
-  /** Calculate closest node to the right */
-  selectRight(targetID) {
-    const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
-    if (!targetNode) {
-      return null;
-    }
-    const operationNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o"));
-    const rightNodes = operationNodes.filter((pos) => pos.x >= targetNode.x);
-    if (rightNodes.length === 0) {
-      return null;
-    }
-    const similarYNodes = rightNodes.filter((pos) => Math.abs(pos.y - targetNode.y) <= MIN_DISTANCE);
-    let closestNode = null;
-    if (similarYNodes.length > 0) {
-      closestNode = similarYNodes.reduce((prev, curr) => curr.x < prev.x ? curr : prev);
-    } else {
-      closestNode = findClosestNodeByDistance(rightNodes, targetNode);
-    }
-    return closestNode?.nodeID ?? null;
-  }
-  /** Calculate closest node upwards */
-  selectUp(targetID) {
-    const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
-    if (!targetNode) {
-      return null;
-    }
-    const operationNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o"));
-    const upperNodes = operationNodes.filter((pos) => pos.y <= targetNode.y - MIN_DISTANCE);
-    const targetOperation = this.oss.itemByNodeID.get(targetID);
-    if (upperNodes.length === 0 || !targetOperation || targetOperation.nodeType === NodeType.BLOCK) {
-      return null;
-    }
-    const predecessors = this.oss.graph.expandAllInputs([targetOperation.id]);
-    const predecessorNodes = upperNodes.filter((pos) => predecessors.includes(Number(pos.nodeID.slice(1))));
-    let closestNode = null;
-    if (predecessorNodes.length > 0) {
-      closestNode = findClosestNodeByDistance(predecessorNodes, targetNode);
-    } else {
-      closestNode = findClosestNodeByDistance(upperNodes, targetNode);
-    }
-    return closestNode?.nodeID ?? null;
-  }
-  /** Calculate closest node downwards */
-  selectDown(targetID) {
-    const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
-    if (!targetNode) {
-      return null;
-    }
-    const operationNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o"));
-    const lowerNodes = operationNodes.filter((pos) => pos.y >= targetNode.y - MIN_DISTANCE);
-    const targetOperation = this.oss.itemByNodeID.get(targetID);
-    if (lowerNodes.length === 0 || !targetOperation || targetOperation.nodeType === NodeType.BLOCK) {
-      return null;
-    }
-    const descendants = this.oss.graph.expandAllOutputs([targetOperation.id]);
-    const descendantsNodes = lowerNodes.filter((pos) => descendants.includes(Number(pos.nodeID.slice(1))));
-    let closestNode = null;
-    if (descendantsNodes.length > 0) {
-      closestNode = findClosestNodeByDistance(descendantsNodes, targetNode);
-    } else {
-      closestNode = findClosestNodeByDistance(lowerNodes, targetNode);
-    }
-    return closestNode?.nodeID ?? null;
-  }
-  extendParentBounds(parent, child) {
-    if (!parent) {
-      return;
-    }
-    const borderX = child.x + child.width + MIN_DISTANCE;
-    const borderY = child.y + child.height + MIN_DISTANCE;
-    parent.width = Math.max(parent.width, borderX - parent.x);
-    parent.height = Math.max(parent.height, borderY - parent.y);
-  }
-  calculatePositionForFreeOperation(initial) {
-    if (this.oss.operations.length === 0) {
-      return initial;
-    }
-    const freeInputs = this.oss.operations.filter(
-      (operation) => operation.parent === null && (operation.operation_type !== OperationType.SYNTHESIS || operation.arguments.length === 0)
-    ).map((operation) => operation.nodeID);
-    let inputsPositions = this.layout.filter((pos) => freeInputs.includes(pos.nodeID));
-    if (inputsPositions.length === 0) {
-      inputsPositions = this.layout.filter((pos) => pos.nodeID.startsWith("o"));
-    }
-    const maxX = Math.max(...inputsPositions.map((node) => node.x));
-    const minY = Math.min(...inputsPositions.map((node) => node.y));
-    return {
-      x: maxX + OPERATION_NODE_WIDTH + MIN_DISTANCE + GRID_SIZE,
-      y: minY
-    };
-  }
-  calculatePositionForFreeBlock(initial) {
-    const rootBlocks = this.oss.blocks.filter((block) => block.parent === null).map((block) => block.nodeID);
-    const blocksPositions = this.layout.filter((pos) => rootBlocks.includes(pos.nodeID));
-    if (blocksPositions.length === 0) {
-      return initial;
-    }
-    const maxX = Math.max(...blocksPositions.map((node) => node.x + node.width));
-    const minY = Math.min(...blocksPositions.map((node) => node.y));
-    return { ...initial, x: maxX + MIN_DISTANCE, y: minY };
-  }
-  calculateOffsetForParentChange(target, parent) {
-    const newPosition = { ...target };
-    if (parent === null) {
-      const rootElements = this.oss.hierarchy.rootNodes();
-      const positions = this.layout.filter((pos) => rootElements.includes(pos.nodeID));
-      preventOverlap(newPosition, positions);
-    } else if (!rectanglesStrictOverlap(target, parent)) {
-      newPosition.x = parent.x + MIN_DISTANCE;
-      newPosition.y = parent.y + MIN_DISTANCE;
-      const siblings = this.oss.hierarchy.at(parent.nodeID)?.outputs ?? [];
-      const siblingsPositions = this.layout.filter((pos) => siblings.includes(pos.nodeID));
-      preventOverlap(newPosition, siblingsPositions);
-    }
-    return { x: newPosition.x - target.x, y: newPosition.y - target.y };
-  }
+	oss;
+	layout;
+	constructor(oss, layout) {
+		this.oss = oss;
+		if (layout) this.layout = layout;
+		else this.layout = this.oss.layout;
+	}
+	/** Calculate insert position for a new {@link Operation} */
+	newOperationPosition(position, parent, args = []) {
+		const result = { ...position };
+		const parentNode = this.layout.find((pos) => pos.nodeID === `b${parent}`) ?? null;
+		const operations = this.layout.filter((pos) => pos.nodeID.startsWith("o"));
+		const hasArguments = args.length !== 0;
+		if (hasArguments) {
+			const pos = calculatePositionFromArgs(operations.filter((node) => args.includes(Number(node.nodeID.slice(1)))));
+			result.x = pos.x;
+			result.y = pos.y;
+		} else if (parentNode) {
+			result.x = parentNode.x + MIN_DISTANCE;
+			result.y = parentNode.y + MIN_DISTANCE;
+		} else {
+			const pos = this.calculatePositionForFreeOperation(result);
+			result.x = pos.x;
+			result.y = pos.y;
+		}
+		const siblingBlocks = this.oss.blocks.filter((block) => block.parent === parent).map((block) => block.nodeID);
+		preventOverlap(result, this.layout.filter((node) => siblingBlocks.includes(node.nodeID)), {
+			moveX: !hasArguments,
+			moveY: hasArguments
+		});
+		preventOverlap(result, operations);
+		this.extendParentBounds(parentNode, result);
+		return result;
+	}
+	/** Calculate insert position for a new {@link Block} */
+	newBlockPosition(position, parent, blocks, operations) {
+		const blockNodes = blocks.map((id) => this.layout.find((block) => block.nodeID === `b${id}`)).filter((node) => !!node);
+		const operationNodes = operations.map((id) => this.layout.find((operation) => operation.nodeID === `o${id}`)).filter((node) => !!node);
+		const parentNode = this.layout.find((pos) => pos.nodeID === `b${parent}`) ?? null;
+		const parentID = parentNode ? parent : null;
+		let result = { ...position };
+		if (blockNodes.length !== 0 || operationNodes.length !== 0) result = calculatePositionFromChildren(position, operationNodes, blockNodes);
+		else if (parentNode) result = {
+			x: parentNode.x + MIN_DISTANCE,
+			y: parentNode.y + MIN_DISTANCE,
+			width: position.width,
+			height: position.height
+		};
+		else result = this.calculatePositionForFreeBlock(result);
+		if (blockNodes.length === 0 && operationNodes.length === 0) {
+			const siblings = this.oss.blocks.filter((block) => block.parent === parentID).map((block) => block.nodeID);
+			preventOverlap(result, this.layout.filter((node) => siblings.includes(node.nodeID)));
+		}
+		this.extendParentBounds(parentNode, result);
+		return result;
+	}
+	/** Calculate insert position for a new clone of {@link Operation} */
+	newClonePosition(targetID) {
+		const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
+		if (!targetNode) return null;
+		else return {
+			x: targetNode.x + targetNode.width / 2 + 10,
+			y: targetNode.y + targetNode.height / 2 + 10,
+			width: 150,
+			height: 40
+		};
+	}
+	/** Update layout when parent changes */
+	onChangeParent(targetID, newParent) {
+		const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
+		if (!targetNode) return;
+		const parentNode = this.layout.find((pos) => pos.nodeID === newParent) ?? null;
+		const offset = this.calculateOffsetForParentChange(targetNode, parentNode);
+		if (offset.x === 0 && offset.y === 0) return;
+		targetNode.x += offset.x;
+		targetNode.y += offset.y;
+		const children = this.oss.hierarchy.expandAllOutputs([targetID]);
+		const childrenPositions = this.layout.filter((pos) => children.includes(pos.nodeID));
+		for (const child of childrenPositions) {
+			child.x += offset.x;
+			child.y += offset.y;
+		}
+		this.extendParentBounds(parentNode, targetNode);
+	}
+	/** Calculate closest node to the left */
+	selectLeft(targetID) {
+		const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
+		if (!targetNode) return null;
+		const leftNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o")).filter((pos) => pos.x <= targetNode.x);
+		if (leftNodes.length === 0) return null;
+		const similarYNodes = leftNodes.filter((pos) => Math.abs(pos.y - targetNode.y) <= MIN_DISTANCE);
+		let closestNode = null;
+		if (similarYNodes.length > 0) closestNode = similarYNodes.reduce((prev, curr) => curr.x > prev.x ? curr : prev);
+		else closestNode = findClosestNodeByDistance(leftNodes, targetNode);
+		return closestNode?.nodeID ?? null;
+	}
+	/** Calculate closest node to the right */
+	selectRight(targetID) {
+		const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
+		if (!targetNode) return null;
+		const rightNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o")).filter((pos) => pos.x >= targetNode.x);
+		if (rightNodes.length === 0) return null;
+		const similarYNodes = rightNodes.filter((pos) => Math.abs(pos.y - targetNode.y) <= MIN_DISTANCE);
+		let closestNode = null;
+		if (similarYNodes.length > 0) closestNode = similarYNodes.reduce((prev, curr) => curr.x < prev.x ? curr : prev);
+		else closestNode = findClosestNodeByDistance(rightNodes, targetNode);
+		return closestNode?.nodeID ?? null;
+	}
+	/** Calculate closest node upwards */
+	selectUp(targetID) {
+		const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
+		if (!targetNode) return null;
+		const upperNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o")).filter((pos) => pos.y <= targetNode.y - MIN_DISTANCE);
+		const targetOperation = this.oss.itemByNodeID.get(targetID);
+		if (upperNodes.length === 0 || !targetOperation || targetOperation.nodeType === NodeType.BLOCK) return null;
+		const predecessors = this.oss.graph.expandAllInputs([targetOperation.id]);
+		const predecessorNodes = upperNodes.filter((pos) => predecessors.includes(Number(pos.nodeID.slice(1))));
+		let closestNode = null;
+		if (predecessorNodes.length > 0) closestNode = findClosestNodeByDistance(predecessorNodes, targetNode);
+		else closestNode = findClosestNodeByDistance(upperNodes, targetNode);
+		return closestNode?.nodeID ?? null;
+	}
+	/** Calculate closest node downwards */
+	selectDown(targetID) {
+		const targetNode = this.layout.find((pos) => pos.nodeID === targetID);
+		if (!targetNode) return null;
+		const lowerNodes = this.layout.filter((pos) => pos.nodeID !== targetID && pos.nodeID.startsWith("o")).filter((pos) => pos.y >= targetNode.y - MIN_DISTANCE);
+		const targetOperation = this.oss.itemByNodeID.get(targetID);
+		if (lowerNodes.length === 0 || !targetOperation || targetOperation.nodeType === NodeType.BLOCK) return null;
+		const descendants = this.oss.graph.expandAllOutputs([targetOperation.id]);
+		const descendantsNodes = lowerNodes.filter((pos) => descendants.includes(Number(pos.nodeID.slice(1))));
+		let closestNode = null;
+		if (descendantsNodes.length > 0) closestNode = findClosestNodeByDistance(descendantsNodes, targetNode);
+		else closestNode = findClosestNodeByDistance(lowerNodes, targetNode);
+		return closestNode?.nodeID ?? null;
+	}
+	extendParentBounds(parent, child) {
+		if (!parent) return;
+		const borderX = child.x + child.width + MIN_DISTANCE;
+		const borderY = child.y + child.height + MIN_DISTANCE;
+		parent.width = Math.max(parent.width, borderX - parent.x);
+		parent.height = Math.max(parent.height, borderY - parent.y);
+	}
+	calculatePositionForFreeOperation(initial) {
+		if (this.oss.operations.length === 0) return initial;
+		const freeInputs = this.oss.operations.filter((operation) => operation.parent === null && (operation.operation_type !== OperationType.SYNTHESIS || operation.arguments.length === 0)).map((operation) => operation.nodeID);
+		let inputsPositions = this.layout.filter((pos) => freeInputs.includes(pos.nodeID));
+		if (inputsPositions.length === 0) inputsPositions = this.layout.filter((pos) => pos.nodeID.startsWith("o"));
+		const maxX = Math.max(...inputsPositions.map((node) => node.x));
+		const minY = Math.min(...inputsPositions.map((node) => node.y));
+		return {
+			x: maxX + 150 + MIN_DISTANCE + 10,
+			y: minY
+		};
+	}
+	calculatePositionForFreeBlock(initial) {
+		const rootBlocks = this.oss.blocks.filter((block) => block.parent === null).map((block) => block.nodeID);
+		const blocksPositions = this.layout.filter((pos) => rootBlocks.includes(pos.nodeID));
+		if (blocksPositions.length === 0) return initial;
+		const maxX = Math.max(...blocksPositions.map((node) => node.x + node.width));
+		const minY = Math.min(...blocksPositions.map((node) => node.y));
+		return {
+			...initial,
+			x: maxX + MIN_DISTANCE,
+			y: minY
+		};
+	}
+	calculateOffsetForParentChange(target, parent) {
+		const newPosition = { ...target };
+		if (parent === null) {
+			const rootElements = this.oss.hierarchy.rootNodes();
+			preventOverlap(newPosition, this.layout.filter((pos) => rootElements.includes(pos.nodeID)));
+		} else if (!rectanglesStrictOverlap(target, parent)) {
+			newPosition.x = parent.x + MIN_DISTANCE;
+			newPosition.y = parent.y + MIN_DISTANCE;
+			const siblings = this.oss.hierarchy.at(parent.nodeID)?.outputs ?? [];
+			preventOverlap(newPosition, this.layout.filter((pos) => siblings.includes(pos.nodeID)));
+		}
+		return {
+			x: newPosition.x - target.x,
+			y: newPosition.y - target.y
+		};
+	}
 };
 function rectanglesOverlap(a, b) {
-  return !(a.x + a.width + MIN_DISTANCE <= b.x || b.x + b.width + MIN_DISTANCE <= a.x || a.y + a.height + MIN_DISTANCE <= b.y || b.y + b.height + MIN_DISTANCE <= a.y);
+	return !(a.x + a.width + MIN_DISTANCE <= b.x || b.x + b.width + MIN_DISTANCE <= a.x || a.y + a.height + MIN_DISTANCE <= b.y || b.y + b.height + MIN_DISTANCE <= a.y);
 }
 function rectanglesStrictOverlap(a, b) {
-  return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
+	return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
 }
-function preventOverlap(target, fixedRectangles, options = { moveX: true, moveY: true }) {
-  if (!options.moveX && !options.moveY || fixedRectangles.length === 0) {
-    return;
-  }
-  let hasOverlap;
-  do {
-    hasOverlap = false;
-    for (const fixed of fixedRectangles) {
-      if (rectanglesOverlap(target, fixed)) {
-        hasOverlap = true;
-        if (options.moveX) {
-          target.x += MIN_DISTANCE;
-        }
-        if (options.moveY) {
-          target.y += MIN_DISTANCE;
-        }
-        break;
-      }
-    }
-  } while (hasOverlap);
+function preventOverlap(target, fixedRectangles, options = {
+	moveX: true,
+	moveY: true
+}) {
+	if (!options.moveX && !options.moveY || fixedRectangles.length === 0) return;
+	let hasOverlap;
+	do {
+		hasOverlap = false;
+		for (const fixed of fixedRectangles) if (rectanglesOverlap(target, fixed)) {
+			hasOverlap = true;
+			if (options.moveX) target.x += MIN_DISTANCE;
+			if (options.moveY) target.y += MIN_DISTANCE;
+			break;
+		}
+	} while (hasOverlap);
 }
 function calculatePositionFromArgs(args) {
-  const maxY = Math.max(...args.map((node) => node.y));
-  const minX = Math.min(...args.map((node) => node.x));
-  const maxX = Math.max(...args.map((node) => node.x));
-  return {
-    x: Math.ceil((maxX + minX) / 2 / GRID_SIZE) * GRID_SIZE,
-    y: maxY + 2 * OPERATION_NODE_HEIGHT + MIN_DISTANCE
-  };
+	const maxY = Math.max(...args.map((node) => node.y));
+	const minX = Math.min(...args.map((node) => node.x));
+	const maxX = Math.max(...args.map((node) => node.x));
+	return {
+		x: Math.ceil((maxX + minX) / 2 / 10) * 10,
+		y: maxY + 80 + MIN_DISTANCE
+	};
 }
 function calculatePositionFromChildren(initial, operations, blocks) {
-  const allNodes = [...blocks, ...operations];
-  if (allNodes.length === 0) {
-    return initial;
-  }
-  const left = Math.min(...allNodes.map((n) => n.x)) - MIN_DISTANCE;
-  const top = Math.min(...allNodes.map((n) => n.y)) - MIN_DISTANCE;
-  const right = Math.max(...allNodes.map((n) => n.x + n.width)) + MIN_DISTANCE;
-  const bottom = Math.max(...allNodes.map((n) => n.y + n.height)) + MIN_DISTANCE;
-  return {
-    x: left,
-    y: top,
-    width: right - left,
-    height: bottom - top
-  };
+	const allNodes = [...blocks, ...operations];
+	if (allNodes.length === 0) return initial;
+	const left = Math.min(...allNodes.map((n) => n.x)) - MIN_DISTANCE;
+	const top = Math.min(...allNodes.map((n) => n.y)) - MIN_DISTANCE;
+	const right = Math.max(...allNodes.map((n) => n.x + n.width)) + MIN_DISTANCE;
+	const bottom = Math.max(...allNodes.map((n) => n.y + n.height)) + MIN_DISTANCE;
+	return {
+		x: left,
+		y: top,
+		width: right - left,
+		height: bottom - top
+	};
 }
 function findClosestNodeByDistance(nodes, target) {
-  let minDist = Infinity;
-  let minNode = null;
-  for (const curr of nodes) {
-    const currDist = Math.hypot(curr.x - target.x, curr.y - target.y);
-    if (currDist < minDist) {
-      minDist = currDist;
-      minNode = curr;
-    }
-  }
-  return minNode;
+	let minDist = Infinity;
+	let minNode = null;
+	for (const curr of nodes) {
+		const currDist = Math.hypot(curr.x - target.x, curr.y - target.y);
+		if (currDist < minDist) {
+			minDist = currDist;
+			minNode = curr;
+		}
+	}
+	return minNode;
 }
-export {
-  GRID_SIZE,
-  LayoutManager,
-  OPERATION_NODE_HEIGHT,
-  OPERATION_NODE_WIDTH
-};
+//#endregion
+export { GRID_SIZE, LayoutManager, OPERATION_NODE_HEIGHT, OPERATION_NODE_WIDTH };
+
 //# sourceMappingURL=oss-layout-api.js.map