Method updateTreeHelper

frontend/layout/lib/layoutModel.ts:785–886

* Per-node callback that is invoked recursively to find leaf nodes, update the resize handles, and compute additional properties associated with the given node. * @param node The node for which to update the resize handles and additional properties. * @param additionalPropsMap The new map

(
        node: LayoutNode,
        additionalPropsMap: Record<string, LayoutNodeAdditionalProps>,
        leafs: LayoutNode[],
        resizeHandleSizePx: number,
        magnifiedNodeSizePct: number,
        boundingRect: Dimensions,
        resizeAction?: LayoutTreeResizeNodeAction
    )

     * @param resizeAction The pending resize action, if any. Used to set temporary size values on nodes that are being resized.
     */
    private updateTreeHelper(
        node: LayoutNode,
        additionalPropsMap: Record<string, LayoutNodeAdditionalProps>,
        leafs: LayoutNode[],
        resizeHandleSizePx: number,
        magnifiedNodeSizePct: number,
        boundingRect: Dimensions,
        resizeAction?: LayoutTreeResizeNodeAction
    ) {
        if (!node.children?.length) {
            leafs.push(node);
            const addlProps = additionalPropsMap[node.id];
            if (addlProps) {
                if (this.magnifiedNodeId === node.id) {
                    const magnifiedNodeMarginPct = (1 - magnifiedNodeSizePct) / 2;
                    const transform = setTransform(
                        {
                            top: boundingRect.height * magnifiedNodeMarginPct,
                            left: boundingRect.width * magnifiedNodeMarginPct,
                            width: boundingRect.width * magnifiedNodeSizePct,
                            height: boundingRect.height * magnifiedNodeSizePct,
                        },
                        true,
                        true,
                        "var(--zindex-layout-magnified-node)"
                    );
                    addlProps.transform = transform;
                }
                if (this.lastMagnifiedNodeId === node.id) {
                    addlProps.transform.zIndex = "var(--zindex-layout-last-magnified-node)";
                } else if (this.lastEphemeralNodeId === node.id) {
                    addlProps.transform.zIndex = "var(--zindex-layout-last-ephemeral-node)";
                }
            }
            return;
        }

        function getNodeSize(node: LayoutNode) {
            return resizeAction?.resizeOperations.find((op) => op.nodeId === node.id)?.size ?? node.size;
        }

        const additionalProps: LayoutNodeAdditionalProps = node.id in additionalPropsMap
            ? additionalPropsMap[node.id]
            : { treeKey: "0" };

        const nodeRect: Dimensions = node.id === this.treeState.rootNode.id ? boundingRect : additionalProps.rect;
        const nodeIsRow = node.flexDirection === FlexDirection.Row;
        const nodePixels = nodeIsRow ? nodeRect.width : nodeRect.height;
        const totalChildrenSize = node.children.reduce((acc, child) => acc + getNodeSize(child), 0);
        const pixelToSizeRatio = totalChildrenSize / nodePixels;

        let lastChildRect: Dimensions;
        const resizeHandles: ResizeHandleProps[] = [];
        node.children.forEach((child, i) => {
            const childSize = getNodeSize(child);
            const rect: Dimensions = {
                top: !nodeIsRow && lastChildRect ? lastChildRect.top + lastChildRect.height : nodeRect.top,
                left: nodeIsRow && lastChildRect ? lastChildRect.left + lastChildRect.width : nodeRect.left,