@ozen-ui/kit/__inner__/esm/utils/breakpoint/calculateIsBreakpoints.js

React component library

import { __read, __values } from "tslib";
import { BREAKPOINT_PREFIX } from '../../types/Breakpoints';
import { capitalizeFirstLetter } from '../capitalizeFirstLetter';
var memoizedBreakpointsMatches = {};
var generateIsBreakpointKey = function (prefix, breakpoint) {
    return "".concat(prefix).concat(capitalizeFirstLetter(breakpoint));
};
var checkIsCurrentBreakpoint = function (isBreakpoint, breakpoint) { return isBreakpoint[generateIsBreakpointKey(BREAKPOINT_PREFIX.IS, breakpoint)]; };
var checkHasALargerThan = function (breakpointsAscending, isBreakpoint, breakpoint) {
    var breakpointIndex = breakpointsAscending.indexOf(breakpoint);
    var largerBreakpoints = breakpointsAscending.slice(breakpointIndex + 1, breakpointsAscending.length);
    var hasLargerBreakpointThanThis = largerBreakpoints.some(function (breakpoint) {
        return checkIsCurrentBreakpoint(isBreakpoint, breakpoint);
    });
    return hasLargerBreakpointThanThis;
};
var checkHasASmallerThan = function (breakpointsAscending, isBreakpoint, breakpoint) {
    var breakpointIndex = breakpointsAscending.indexOf(breakpoint);
    var smallerBreakpoints = breakpointsAscending.slice(0, breakpointIndex);
    var hasSmallerBreakpointThanThis = smallerBreakpoints.some(function (breakpoint) {
        return checkIsCurrentBreakpoint(isBreakpoint, breakpoint);
    });
    return hasSmallerBreakpointThanThis;
};
var checkIsBreakpoint = function (minWidthByBreakpoint, breakpointsAscending, windowWidth, breakpoint) {
    var breakpointIndex = breakpointsAscending.indexOf(breakpoint);
    var previousBreakpoint = minWidthByBreakpoint[breakpointsAscending[breakpointIndex - 1]];
    var currentBreakpoint = minWidthByBreakpoint[breakpoint];
    var nextBreakpoint = minWidthByBreakpoint[breakpointsAscending[breakpointIndex + 1]];
    var isTheSmallestBreakpoint = breakpointIndex === 0;
    if (isTheSmallestBreakpoint) {
        return windowWidth < nextBreakpoint;
    }
    var isTheLargestBreakpoint = breakpointIndex === breakpointsAscending.length - 1;
    if (isTheLargestBreakpoint) {
        return windowWidth >= currentBreakpoint && windowWidth > previousBreakpoint;
    }
    return (windowWidth >= minWidthByBreakpoint[breakpoint] &&
        windowWidth < nextBreakpoint);
};
export var getBreakpointsAscending = function (breakpointToken) {
    return Object.entries(breakpointToken.properties)
        // eslint-disable-next-line @typescript-eslint/no-unused-vars
        .sort(function (_c, _d) {
        var _e = __read(_c, 2), _a = _e[0], breakpointA = _e[1];
        var _f = __read(_d, 2), _b = _f[0], breakpointB = _f[1];
        return breakpointA - breakpointB;
    })
        .map(function (_c) {
        var _d = __read(_c, 1), deviceSize = _d[0];
        return deviceSize;
    });
};
export var calculateBreakpoints = function (breakpointToken, windowWidth) {
    var e_1, _c;
    var matches = {};
    var breakpointsAscending = getBreakpointsAscending(breakpointToken);
    try {
        for (var breakpointsAscending_1 = __values(breakpointsAscending), breakpointsAscending_1_1 = breakpointsAscending_1.next(); !breakpointsAscending_1_1.done; breakpointsAscending_1_1 = breakpointsAscending_1.next()) {
            var breakpoint = breakpointsAscending_1_1.value;
            var isThisBreakpoint = checkIsBreakpoint(breakpointToken.properties, breakpointsAscending, windowWidth, breakpoint);
            matches[generateIsBreakpointKey(BREAKPOINT_PREFIX.IS, breakpoint)] =
                isThisBreakpoint;
            if (isThisBreakpoint) {
                var memoizedValue = memoizedBreakpointsMatches[breakpoint];
                if (memoizedValue) {
                    return memoizedValue;
                }
                matches.currentBreakpoint = breakpoint;
            }
        }
    }
    catch (e_1_1) { e_1 = { error: e_1_1 }; }
    finally {
        try {
            if (breakpointsAscending_1_1 && !breakpointsAscending_1_1.done && (_c = breakpointsAscending_1.return)) _c.call(breakpointsAscending_1);
        }
        finally { if (e_1) throw e_1.error; }
    }
    breakpointsAscending.forEach(function (breakpoint) {
        var isCurrentBreakpoint = checkIsCurrentBreakpoint(matches, breakpoint);
        var hasALargerThan = checkHasALargerThan(breakpointsAscending, matches, breakpoint);
        var hasASmallerThan = checkHasASmallerThan(breakpointsAscending, matches, breakpoint);
        matches[generateIsBreakpointKey(BREAKPOINT_PREFIX.IS_A_LARGER_THAN, breakpoint)] = hasALargerThan;
        matches[generateIsBreakpointKey(BREAKPOINT_PREFIX.IS_A_SMALLER_THAN, breakpoint)] = hasASmallerThan;
        matches[generateIsBreakpointKey(BREAKPOINT_PREFIX.IS_A_LARGER_THAN_OR_IS, breakpoint)] = hasALargerThan || isCurrentBreakpoint;
        matches[generateIsBreakpointKey(BREAKPOINT_PREFIX.IS_A_SMALLER_THAN_OR_IS, breakpoint)] = hasASmallerThan || isCurrentBreakpoint;
    });
    memoizedBreakpointsMatches[matches.currentBreakpoint] = matches;
    return matches;
};