@ozen-ui/kit/__inner__/esm/components/StepperVertical/hooks/useStepperVerticalStepsStructure/useStepperVerticalStepsStructure.js

React component library

import { useMemo, useEffect } from 'react';
import { useEventBus } from '../../../../hooks/useEventBus';
import { useStoredValue } from '../../../../hooks/useStoredValue';
import { cnCollapse } from '../../../Collapse';
export var useStepperVerticalStepsStructure = function (ref, stepsControl, children) {
    var eventBus = useEventBus();
    var structure = useStoredValue({
        nodes: [],
        nodeById: {},
    });
    var calculate = function () {
        var element = ref.current;
        if (!element) {
            return { nodes: [], nodeById: {} };
        }
        var nodeById = {};
        var nodes = [];
        var stepsControlSteps = Object.values(stepsControl.steps.current);
        var collectNodeSubsteps = function (node, element) {
            var substeps = Object.values(node.step.substeps);
            if (substeps.length === 0) {
                return;
            }
            var nextElement = element.nextElementSibling;
            if (!nextElement) {
                throw new Error('Ожидается следующий элемент для шага с подшагами');
            }
            var isNextElementCollapse = nextElement.classList.contains(cnCollapse());
            if (!isNextElementCollapse) {
                throw new Error('Ожидается collapse для подшагов');
            }
            var collapseInner = nextElement.firstElementChild;
            if (!collapseInner) {
                throw new Error('Не удалось получить inner для collapse');
            }
            Array.from(collapseInner.childNodes).forEach(function (collapseStep) {
                var relatedSubstep = substeps.find(function (substep) { return substep.ref.current === collapseStep; });
                if (!relatedSubstep) {
                    return;
                }
                var newNode = {
                    root: node,
                    step: relatedSubstep,
                    substeps: [],
                };
                nodeById[relatedSubstep.id] = newNode;
                node.substeps.push(newNode);
                if (Object.keys(relatedSubstep.substeps).length > 0) {
                    collectNodeSubsteps(newNode, relatedSubstep.ref.current);
                }
            });
        };
        element.childNodes.forEach(function (node) {
            var relatedStep = stepsControlSteps.find(function (step) { return step.ref.current === node; });
            if (!relatedStep) {
                return;
            }
            var newNode = {
                root: null,
                step: relatedStep,
                substeps: [],
            };
            nodeById[relatedStep.id] = newNode;
            nodes.push(newNode);
            collectNodeSubsteps(newNode, newNode.step.ref.current);
        });
        return { nodeById: nodeById, nodes: nodes };
    };
    var recalculate = function () {
        var newStructure = calculate();
        structure.current = newStructure;
        eventBus.publish('update', { structure: structure.current });
    };
    useEffect(function () {
        recalculate();
    }, [children]);
    return useMemo(function () { return ({ value: structure, eventBus: eventBus }); }, []);
};