antd/es/_util/responsiveObserver.js

An enterprise-class UI design language and React components implementation

import React from 'react';
import { useToken } from '../theme/internal';
import { isFunction } from './is';
export const responsiveArray = ['xxxl', 'xxl', 'xl', 'lg', 'md', 'sm', 'xs'];
export const responsiveArrayReversed = [].concat(responsiveArray).reverse();
const getResponsiveMap = token => ({
  xs: `(max-width: ${token.screenXSMax}px)`,
  sm: `(min-width: ${token.screenSM}px)`,
  md: `(min-width: ${token.screenMD}px)`,
  lg: `(min-width: ${token.screenLG}px)`,
  xl: `(min-width: ${token.screenXL}px)`,
  xxl: `(min-width: ${token.screenXXL}px)`,
  xxxl: `(min-width: ${token.screenXXXL}px)`
});
/**
 * Ensures that the breakpoints token are valid, in good order
 * For each breakpoint : screenMin <= screen <= screenMax and screenMax <= nextScreenMin
 */
const validateBreakpoints = token => {
  const indexableToken = token;
  const revBreakpoints = [].concat(responsiveArray).reverse();
  revBreakpoints.forEach((breakpoint, i) => {
    const breakpointUpper = breakpoint.toUpperCase();
    const screenMin = `screen${breakpointUpper}Min`;
    const screen = `screen${breakpointUpper}`;
    if (!(indexableToken[screenMin] <= indexableToken[screen])) {
      throw new Error(`${screenMin}<=${screen} fails : !(${indexableToken[screenMin]}<=${indexableToken[screen]})`);
    }
    if (i < revBreakpoints.length - 1) {
      const screenMax = `screen${breakpointUpper}Max`;
      if (!(indexableToken[screen] <= indexableToken[screenMax])) {
        throw new Error(`${screen}<=${screenMax} fails : !(${indexableToken[screen]}<=${indexableToken[screenMax]})`);
      }
      const nextBreakpointUpperMin = revBreakpoints[i + 1].toUpperCase();
      const nextScreenMin = `screen${nextBreakpointUpperMin}Min`;
      if (!(indexableToken[screenMax] <= indexableToken[nextScreenMin])) {
        throw new Error(`${screenMax}<=${nextScreenMin} fails : !(${indexableToken[screenMax]}<=${indexableToken[nextScreenMin]})`);
      }
    }
  });
  return token;
};
export const matchScreen = (screens, screenSizes) => {
  if (!screenSizes) {
    return;
  }
  for (const breakpoint of responsiveArray) {
    if (screens[breakpoint] && screenSizes?.[breakpoint] !== undefined) {
      return screenSizes[breakpoint];
    }
  }
};
const useResponsiveObserver = () => {
  const [, token] = useToken();
  const {
    xs,
    sm,
    md,
    lg,
    xl,
    xxl,
    xxxl
  } = getResponsiveMap(validateBreakpoints(token));
  // To avoid repeat create instance, we add `useMemo` here.
  return React.useMemo(() => {
    const responsiveMap = {
      xs,
      sm,
      md,
      lg,
      xl,
      xxl,
      xxxl
    };
    const subscribers = new Map();
    let subUid = -1;
    let screens;
    return {
      responsiveMap,
      matchHandlers: {},
      getSnapshot() {
        // Read client breakpoints before the first commit without registering listeners in render.
        screens ?? (screens = Object.fromEntries(Object.entries(responsiveMap).map(([screen, query]) => [screen, window.matchMedia(query).matches])));
        return screens;
      },
      getServerSnapshot: () => undefined,
      dispatch(pointMap) {
        if (!screens || responsiveArray.some(screen => screens?.[screen] !== pointMap[screen])) {
          screens = pointMap;
          subscribers.forEach(func => {
            func(pointMap);
          });
        }
        return subscribers.size >= 1;
      },
      subscribe(func) {
        if (!subscribers.size) {
          this.register();
        }
        subUid += 1;
        subscribers.set(subUid, func);
        // Register initializes all breakpoints before notifying the first subscriber.
        func(screens);
        return subUid;
      },
      unsubscribe(paramToken) {
        subscribers.delete(paramToken);
        if (!subscribers.size) {
          this.unregister();
        }
      },
      register() {
        Object.entries(responsiveMap).forEach(([screen, mediaQuery]) => {
          const listener = ({
            matches
          }) => {
            this.dispatch({
              ...screens,
              [screen]: matches
            });
          };
          const mql = window.matchMedia(mediaQuery);
          if (isFunction(mql.addEventListener)) {
            mql.addEventListener('change', listener);
          }
          this.matchHandlers[mediaQuery] = {
            mql,
            listener
          };
          listener(mql);
        });
      },
      unregister() {
        Object.values(responsiveMap).forEach(mediaQuery => {
          const handler = this.matchHandlers[mediaQuery];
          if (isFunction(handler?.mql.removeEventListener)) {
            handler.mql.removeEventListener('change', handler?.listener);
          }
        });
        subscribers.clear();
      }
    };
  }, [xs, sm, md, lg, xl, xxl, xxxl]);
};
export default useResponsiveObserver;