@ringcentral/spring-base 1.12.0 → 1.13.0

package/chunks/twMerge.js

@@ -1,503 +0,0 @@
-import { unstable_ownerWindow } from '@mui/utils';
-import { isValidElement } from 'react';
-import isPlainObject from 'lodash/isPlainObject';
-import { rcConfiguration } from '../config.js';
-import { extendTailwindMerge } from 'tailwind-merge';
-
-const ownerWindow = unstable_ownerWindow;
-
-const ARIA_HIDDEN = 'aria-hidden';
-const TOP_LAYER_ATTR = 'data-sui-top-layer';
-const alwaysVisibleSelector = `[data-live-announcer="true"], [${TOP_LAYER_ATTR}]`;
-const ARIA_HIDDEN_REF_COUNT_MAP = '__SUI_ARIA_HIDE_OUTSIDE_REF_COUNT_MAP__';
-const INERT_REF_COUNT_MAP = '__SUI_ARIA_HIDE_OUTSIDE_INERT_REF_COUNT_MAP__';
-const getRefCountMap = (window, mechanism) => {
-    const key = mechanism === 'inert' ? INERT_REF_COUNT_MAP : ARIA_HIDDEN_REF_COUNT_MAP;
-    if (!window[key]) {
-        window[key] = new WeakMap();
-    }
-    return window[key];
-};
-const OBSERVER_STACK = '__SUI_ARIA_HIDE_OUTSIDE_OBSERVER_STACK__';
-const getObserverStack = (window) => {
-    if (!window[OBSERVER_STACK]) {
-        window[OBSERVER_STACK] = [];
-    }
-    return window[OBSERVER_STACK];
-};
-const isElement = (node) => {
-    return (typeof node === 'object' &&
-        node != null &&
-        'nodeType' in node &&
-        node.nodeType === 1);
-};
-const isAlwaysVisibleNode = (node) => {
-    return (node.getAttribute('data-live-announcer') === 'true' ||
-        node.hasAttribute(TOP_LAYER_ATTR));
-};
-const createAriaHideOutsideController = (targets, options = {}) => {
-    const isLegacyRoot = isElement(options);
-    const configuredRoot = isLegacyRoot
-        ? options
-        : options.root;
-    const currentWindow = ownerWindow(configuredRoot ?? targets[0]);
-    if (!currentWindow) {
-        return {
-            addTarget: () => { },
-            removeTarget: () => { },
-            dispose: () => { },
-        };
-    }
-    const root = configuredRoot ?? currentWindow.document.body;
-    const shouldUseInert = !isLegacyRoot &&
-        options.shouldUseInert &&
-        'inert' in currentWindow.HTMLElement.prototype;
-    const visibleNodes = new Set(targets);
-    const targetNodes = new Set(targets);
-    const automaticVisibleNodes = new Set();
-    const hiddenNodes = new Set();
-    const targetPaths = new Map();
-    const getTargetPath = (target) => {
-        const path = [];
-        let node = target;
-        while (node && root.contains(node)) {
-            path.push(node);
-            if (node === root) {
-                break;
-            }
-            node = node.parentElement;
-        }
-        return path;
-    };
-    for (const target of targets) {
-        targetPaths.set(target, getTargetPath(target));
-    }
-    const observerStack = getObserverStack(currentWindow);
-    const getHideMechanism = (node) => shouldUseInert && node instanceof currentWindow.HTMLElement
-        ? 'inert'
-        : 'aria-hidden';
-    const getHidden = (node, mechanism) => mechanism === 'inert'
-        ? node.inert
-        : node.getAttribute(ARIA_HIDDEN) === 'true';
-    const setHidden = (node, mechanism, hidden) => {
-        if (mechanism === 'inert') {
-            node.inert = hidden;
-        }
-        else if (hidden) {
-            node.setAttribute(ARIA_HIDDEN, 'true');
-        }
-        else {
-            node.removeAttribute(ARIA_HIDDEN);
-        }
-    };
-    const restoreHiddenNode = (node) => {
-        if (!hiddenNodes.delete(node)) {
-            return;
-        }
-        const mechanism = getHideMechanism(node);
-        const refCountMap = getRefCountMap(currentWindow, mechanism);
-        const count = refCountMap.get(node);
-        if (typeof count !== 'number') {
-            return;
-        }
-        if (count === 1) {
-            setHidden(node, mechanism, false);
-            refCountMap.delete(node);
-        }
-        else {
-            refCountMap.set(node, count - 1);
-        }
-    };
-    const hide = (node) => {
-        if (hiddenNodes.has(node)) {
-            return;
-        }
-        const mechanism = getHideMechanism(node);
-        const refCountMap = getRefCountMap(currentWindow, mechanism);
-        const refCount = refCountMap.get(node) ?? 0;
-        if (getHidden(node, mechanism) && refCount === 0) {
-            return;
-        }
-        if (refCount === 0) {
-            setHidden(node, mechanism, true);
-        }
-        hiddenNodes.add(node);
-        refCountMap.set(node, refCount + 1);
-    };
-    const addAlwaysVisibleNode = (node) => {
-        automaticVisibleNodes.add(node);
-        visibleNodes.add(node);
-    };
-    const addAlwaysVisibleNodes = (node) => {
-        if (isAlwaysVisibleNode(node)) {
-            addAlwaysVisibleNode(node);
-        }
-        for (const alwaysVisibleNode of node.querySelectorAll(alwaysVisibleSelector)) {
-            addAlwaysVisibleNode(alwaysVisibleNode);
-        }
-    };
-    const removeDisconnectedAlwaysVisibleNodes = (node) => {
-        for (const alwaysVisibleNode of automaticVisibleNodes) {
-            if (!node.contains(alwaysVisibleNode) ||
-                root.contains(alwaysVisibleNode)) {
-                continue;
-            }
-            automaticVisibleNodes.delete(alwaysVisibleNode);
-            if (!targetNodes.has(alwaysVisibleNode)) {
-                visibleNodes.delete(alwaysVisibleNode);
-            }
-        }
-    };
-    const containsNode = (nodes, node) => {
-        for (const candidate of nodes) {
-            if (candidate.contains(node)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    const containsVisibleNode = (node, nodes) => {
-        for (const visibleNode of nodes) {
-            if (node.contains(visibleNode)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    const isCoveredByHiddenNode = (node) => {
-        let ancestor = node.parentElement;
-        while (ancestor && root.contains(ancestor)) {
-            if (hiddenNodes.has(ancestor)) {
-                return !(ancestor === node.parentElement &&
-                    ancestor.getAttribute('role') === 'row');
-            }
-            ancestor = ancestor.parentElement;
-        }
-        return false;
-    };
-    const shouldAdoptHiddenNode = (node) => {
-        return (root.contains(node) &&
-            !hiddenNodes.has(node) &&
-            !containsNode(visibleNodes, node) &&
-            !containsVisibleNode(node, visibleNodes) &&
-            !isCoveredByHiddenNode(node));
-    };
-    const acceptNode = (node) => {
-        if (visibleNodes.has(node) ||
-            (node.parentElement &&
-                hiddenNodes.has(node.parentElement) &&
-                node.parentElement.getAttribute('role') !== 'row')) {
-            return currentWindow.NodeFilter.FILTER_REJECT;
-        }
-        if (containsVisibleNode(node, visibleNodes)) {
-            return currentWindow.NodeFilter.FILTER_SKIP;
-        }
-        return currentWindow.NodeFilter.FILTER_ACCEPT;
-    };
-    const walk = (walkRoot, includeRoot) => {
-        addAlwaysVisibleNodes(walkRoot);
-        const rootFilter = acceptNode(walkRoot);
-        if (includeRoot && rootFilter === currentWindow.NodeFilter.FILTER_ACCEPT) {
-            hide(walkRoot);
-        }
-        if (rootFilter === currentWindow.NodeFilter.FILTER_REJECT) {
-            return;
-        }
-        const walker = currentWindow.document.createTreeWalker(walkRoot, currentWindow.NodeFilter.SHOW_ELEMENT, { acceptNode });
-        let node = walker.nextNode();
-        while (node != null) {
-            hide(node);
-            node = walker.nextNode();
-        }
-    };
-    const addTarget = (target) => {
-        if (!root.contains(target)) {
-            return;
-        }
-        targetNodes.add(target);
-        visibleNodes.add(target);
-        const path = getTargetPath(target);
-        const restoredAncestorIndexes = [];
-        for (let index = 0; index < path.length; index++) {
-            if (index > 0 && hiddenNodes.has(path[index])) {
-                restoredAncestorIndexes.push(index);
-            }
-            restoreHiddenNode(path[index]);
-        }
-        targetPaths.set(target, path);
-        for (const index of restoredAncestorIndexes) {
-            const ancestor = path[index];
-            const pathChild = path[index - 1];
-            for (const child of ancestor.children) {
-                if (child !== pathChild) {
-                    walk(child, true);
-                }
-            }
-        }
-    };
-    const removeTarget = (target) => {
-        if (!targetNodes.delete(target)) {
-            return;
-        }
-        if (!automaticVisibleNodes.has(target)) {
-            visibleNodes.delete(target);
-        }
-        const targetPath = targetPaths.get(target);
-        targetPaths.delete(target);
-        const connectedAncestor = targetPath?.find((node) => root.contains(node));
-        if (!connectedAncestor) {
-            return;
-        }
-        let walkRoot = connectedAncestor;
-        while (walkRoot.parentElement &&
-            walkRoot.parentElement !== root &&
-            !containsVisibleNode(walkRoot.parentElement, visibleNodes)) {
-            walkRoot = walkRoot.parentElement;
-        }
-        walk(walkRoot, true);
-    };
-    if (observerStack.length) {
-        observerStack[observerStack.length - 1].disconnect();
-    }
-    walk(root, false);
-    const processChanges = (changes) => {
-        for (const change of changes) {
-            if (change.type !== 'childList') {
-                continue;
-            }
-            for (const node of change.removedNodes) {
-                if (isElement(node)) {
-                    removeDisconnectedAlwaysVisibleNodes(node);
-                }
-            }
-            if (!change.target.isConnected || change.addedNodes.length === 0) {
-                continue;
-            }
-            if (!containsNode(visibleNodes, change.target) &&
-                !containsNode(hiddenNodes, change.target)) {
-                for (const node of change.addedNodes) {
-                    if (isElement(node) && root.contains(node)) {
-                        walk(node, true);
-                    }
-                }
-            }
-        }
-    };
-    const observer = new currentWindow.MutationObserver(processChanges);
-    observer.observe(root, { childList: true, subtree: true });
-    const observerWrapper = {
-        observe() {
-            observer.observe(root, { childList: true, subtree: true });
-        },
-        resume(releasedHiddenNodes, releasedAlwaysVisibleNodes) {
-            for (const node of releasedAlwaysVisibleNodes) {
-                if (root.contains(node)) {
-                    addAlwaysVisibleNode(node);
-                }
-            }
-            for (const node of releasedHiddenNodes) {
-                if (shouldAdoptHiddenNode(node)) {
-                    hide(node);
-                }
-            }
-            observerWrapper.observe();
-        },
-        disconnect() {
-            observer.disconnect();
-        },
-    };
-    observerStack.push(observerWrapper);
-    let isCleanedUp = false;
-    const dispose = () => {
-        if (isCleanedUp) {
-            return;
-        }
-        isCleanedUp = true;
-        const pendingChanges = observer.takeRecords();
-        observer.disconnect();
-        processChanges(pendingChanges);
-        if (observerWrapper === observerStack[observerStack.length - 1]) {
-            observerStack.pop();
-            const previousObserver = observerStack[observerStack.length - 1];
-            if (previousObserver?.resume) {
-                previousObserver.resume(hiddenNodes, automaticVisibleNodes);
-            }
-            else {
-                previousObserver?.observe();
-            }
-        }
-        else {
-            observerStack.splice(observerStack.indexOf(observerWrapper), 1);
-        }
-        for (const node of [...hiddenNodes]) {
-            restoreHiddenNode(node);
-        }
-        targetPaths.clear();
-        targetNodes.clear();
-        automaticVisibleNodes.clear();
-    };
-    return {
-        addTarget: (target) => {
-            if (!isCleanedUp) {
-                addTarget(target);
-            }
-        },
-        removeTarget: (target) => {
-            if (!isCleanedUp) {
-                removeTarget(target);
-            }
-        },
-        dispose,
-    };
-};
-const ariaHideOutside = (targets, options = {}) => createAriaHideOutsideController(targets, options).dispose;
-
-const combineProps = (baseProps, newProps, coverPropKeys) => innerCombineProps({
-    baseProps,
-    newProps,
-    coverPropKeys,
-});
-const combineClasses = (baseClasses, newClasses) => innerCombineProps({
-    baseProps: baseClasses,
-    newProps: newClasses,
-    combineAllString: true,
-});
-const innerCombineProps = (params) => {
-    const { baseProps, newProps } = params;
-    if (!newProps || Object.keys(newProps).length === 0) {
-        return baseProps;
-    }
-    const outputProps = mergeChildProps(params);
-    return {
-        ...newProps,
-        ...outputProps,
-    };
-};
-function mergeChildProps({ baseProps, newProps, combineAllString, coverPropKeys, }) {
-    const result = Object.keys(baseProps || {}).reduce((output, curr) => {
-        const prop = baseProps[curr];
-        const propTo = newProps[curr];
-        if (propTo !== undefined) {
-            switch (typeof prop) {
-                case 'undefined':
-                    output[curr] = propTo;
-                    break;
-                case 'object': {
-                    if (!isValidElement(propTo) &&
-                        !isValidElement(prop) &&
-                        isPlainObject(propTo) &&
-                        isPlainObject(prop)) {
-                        output[curr] = mergeChildProps({
-                            baseProps: prop,
-                            newProps: propTo || {},
-                            combineAllString: combineAllString || curr === 'classes',
-                        });
-                    }
-                    else {
-                        output[curr] = propTo;
-                    }
-                    break;
-                }
-                case 'string':
-                    if (combineAllString || curr === 'className') {
-                        output[curr] = [prop, propTo]
-                            .filter((x) => typeof x === 'string' && x)
-                            .join(' ');
-                    }
-                    else {
-                        output[curr] = propTo;
-                    }
-                    break;
-                case 'boolean':
-                case 'symbol':
-                case 'bigint':
-                case 'number':
-                    output[curr] = propTo;
-                    break;
-                case 'function':
-                    if (coverPropKeys && coverPropKeys.includes(curr) && propTo) {
-                        output[curr] = propTo;
-                    }
-                    else {
-                        output[curr] = (...args) => {
-                            propTo?.(...args);
-                            prop?.(...args);
-                        };
-                    }
-                    break;
-            }
-        }
-        else {
-            output[curr] = prop;
-        }
-        return output;
-    }, {});
-    if (Object.keys(result).length === 0) {
-        return undefined;
-    }
-    return {
-        ...newProps,
-        ...result,
-    };
-}
-
-function logInDev({ scope, message, level = 'warn', condition = true, }) {
-    if (process.env.NODE_ENV !== 'production' &&
-        condition &&
-        !rcConfiguration.WARNING_IGNORE) {
-        const log = `SPRING [${scope}]: ${message}`;
-        if (process.env.NODE_ENV === 'test' && level === 'error') {
-            throw Error(log);
-        }
-        console[level](log);
-    }
-}
-
-const isRef = (obj) => {
-    return obj && 'current' in obj;
-};
-
-const getRefElement = (ref) => {
-    if (typeof ref === 'function') {
-        return ref();
-    }
-    if (typeof ref === 'object' && isRef(ref)) {
-        return ref.current;
-    }
-    return ref;
-};
-
-const twMerge = extendTailwindMerge({
-    extend: {
-        classGroups: {
-            typography: [
-                {
-                    typography: [() => true],
-                },
-            ],
-            'focus-ring-rounded': [
-                'focus-ring-rounded',
-                {
-                    'focus-ring-rounded': [() => true],
-                },
-            ],
-            'focus-ring-border': [
-                'focus-ring-border',
-                {
-                    'focus-ring-border': [() => true],
-                },
-            ],
-            'focus-ring-border-recoup': [
-                'focus-ring-border-recoup',
-                'no-focus-ring-border-recoup',
-            ],
-            'focus-ring': [
-                {
-                    'focus-ring': [() => true],
-                },
-            ],
-        },
-    },
-});
-
-export { ariaHideOutside as a, combineClasses as b, combineProps as c, createAriaHideOutsideController as d, getRefElement as g, isRef as i, logInDev as l, ownerWindow as o, twMerge as t };