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

React component library

import { __read } from "tslib";
import { useEffect, useState } from 'react';
import { useEventBusEvents } from '../../../hooks/useEventBusEvents';
import { useStepperVerticalContext } from '../StepperVerticalContext';
export var useStepperVerticalStepHelper = function (step) {
    var _a;
    var structure = useStepperVerticalContext().structure;
    var _b = __read(useState(false), 2), hasPrevious = _b[0], setHasPrevious = _b[1];
    var _c = __read(useState(false), 2), hasNext = _c[0], setHasNext = _c[1];
    var getStructureNode = function (forStep) {
        var _a;
        if (forStep === void 0) { forStep = step; }
        var node = (_a = structure.value.current.nodeById[forStep.id]) !== null && _a !== void 0 ? _a : null;
        return node;
    };
    var getNodeIndex = function (node) {
        if (!node.root) {
            return structure.value.current.nodes.indexOf(node);
        }
        return node.root.substeps.indexOf(node);
    };
    var checkHasNext = function (forStep) {
        if (forStep === void 0) { forStep = step; }
        if (forStep.isSubStepsOpen) {
            return true;
        }
        var node = getStructureNode(forStep);
        if (!node) {
            return false;
        }
        var nodeIndex = getNodeIndex(node);
        if (!node.root) {
            return !!structure.value.current.nodes[nodeIndex + 1];
        }
        var sameLevelNext = node.root.substeps[nodeIndex + 1];
        if (sameLevelNext) {
            return true;
        }
        var checkHasTopLevelNext = function (node) {
            if (!node.root) {
                return false;
            }
            var rootIndex = getNodeIndex(node.root);
            var nextStep = node.root.root
                ? node.root.root.substeps[rootIndex + 1]
                : structure.value.current.nodes[rootIndex + 1];
            if (nextStep) {
                return true;
            }
            return checkHasTopLevelNext(node.root);
        };
        var otherLevelNext = checkHasTopLevelNext(node);
        return otherLevelNext;
    };
    var checkHasPrevious = function (forStep) {
        if (forStep === void 0) { forStep = step; }
        var node = getStructureNode(forStep);
        if (!node) {
            return false;
        }
        var nodeIndex = getNodeIndex(node);
        if (!node.root) {
            return !!structure.value.current.nodes[nodeIndex - 1];
        }
        var rootHasNext = checkHasNext(node.root.step);
        if (rootHasNext) {
            return true;
        }
        if (nodeIndex === 0) {
            return node.root.step.isSubStepsOpen;
        }
        return true;
    };
    var recalculate = function () {
        setHasPrevious(checkHasPrevious());
        setHasNext(checkHasNext());
    };
    useEventBusEvents(structure.eventBus, {
        update: recalculate,
    });
    useEffect(function () {
        recalculate();
    }, [step.isSubStepsOpen, (_a = step.root) === null || _a === void 0 ? void 0 : _a.isSubStepsOpen]);
    return {
        hasPrevious: hasPrevious,
        hasNext: hasNext,
    };
};