opendash/dist/hooks/useNavigation.js

open.DASH data visualization framework

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
};
import * as React from "react";
import picomatch from "picomatch";
import { usePath, useAppState, useOpenDashApp, useTranslation } from "..";
export function useNavigation(place) {
    var app = useOpenDashApp();
    var path = usePath();
    var _a = useAppState(function (state) { return [
        state.navigation.userNavigationGroups,
        state.navigation.userNavigationItems,
    ]; }), userGroups = _a[0], userItems = _a[1];
    var groups = React.useMemo(function () {
        return __spreadArrays(userGroups, app.ui.staticNavigationGroups).sort(function (a, b) { return a.order - b.order; });
    }, [userGroups]);
    var items = React.useMemo(function () {
        return __spreadArrays(userItems, app.ui.staticNavigationItems).filter(function (item) { return item.place === place; })
            .filter(function (item) {
            return item.routeCondition
                ? picomatch.isMatch(path, item.routeCondition)
                : true;
        })
            .sort(function (a, b) { return a.order - b.order; });
    }, [userItems, path, place]);
    var namespaces = useNamespaces(groups, items);
    var t = useTranslation(namespaces)[0];
    var activeItems = React.useMemo(function () {
        return items
            .filter(function (item) {
            return item.activeCondition
                ? picomatch.isMatch(path, item.activeCondition)
                : false;
        })
            .map(function (item) { return item.id; });
    }, [items, path]);
    var result = React.useMemo(function () {
        return groups
            .map(function (group) {
            return __assign(__assign({}, group), { label: t(group.label), children: items
                    .filter(function (item) { return item.group === group.id; })
                    .map(function (item) {
                    return __assign(__assign({}, item), { label: t(item.label) });
                }) });
        })
            .filter(function (group) { return group.children.length > 0; });
    }, [groups, items]);
    return [result, items, activeItems];
}
function useNamespaces(groups, items) {
    return React.useMemo(function () {
        return ["translation"].concat(__spreadArrays(groups, items).map(function (_a) {
            var label = _a.label;
            return label;
        })
            .filter(function (v, i, a) { return a.indexOf(v) === i; })
            .map(function (label) {
            var parts = label.split(":");
            if (parts.length > 1) {
                return parts[0];
            }
            return null;
        })
            .filter(Boolean)
            .filter(function (v, i, a) { return a.indexOf(v) === i; }));
    }, [groups, items]);
}
//# sourceMappingURL=useNavigation.js.map