@janiscommerce/ui-web 1.4.0 → 1.5.0-beta.2

package/dist/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('styled-components'), require('react-dom'), require('react-collapsed')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', 'styled-components', 'react-dom', 'react-collapsed'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.main = {}, global.React, global.styled$j, global.ReactDOM, global.reactCollapsed));
-})(this, (function (exports, React, styled$j, ReactDOM, reactCollapsed) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('styled-components'), require('react-dom')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'styled-components', 'react-dom'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.main = {}, global.React, global.styled$j, global.ReactDOM));
+})(this, (function (exports, React, styled$j, ReactDOM) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -715,12 +715,12 @@
 
   var uncurryThis$q = functionUncurryThis;
 
-  var id = 0;
+  var id$1 = 0;
   var postfix = Math.random();
   var toString$b = uncurryThis$q(1.0.toString);
 
   var uid$2 = function (key) {
-    return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$b(++id + postfix, 36);
+    return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$b(++id$1 + postfix, 36);
   };
 
   var global$H = global$T;
@@ -3805,7 +3805,7 @@
   var PATH_START = {};
   var PATH = {};
   var CANNOT_BE_A_BASE_URL_PATH = {};
-  var QUERY = {};
+  var QUERY$1 = {};
   var FRAGMENT = {};
 
   var URLState = function (url, isBase, base) {
@@ -3958,7 +3958,7 @@
               url.port = base.port;
               url.path = arraySlice$4(base.path);
               url.query = '';
-              state = QUERY;
+              state = QUERY$1;
             } else if (chr == '#') {
               url.username = base.username;
               url.password = base.password;
@@ -4094,7 +4094,7 @@
                 url.host = base.host;
                 url.path = arraySlice$4(base.path);
                 url.query = '';
-                state = QUERY;
+                state = QUERY$1;
               } else if (chr == '#') {
                 url.host = base.host;
                 url.path = arraySlice$4(base.path);
@@ -4152,7 +4152,7 @@
               if (chr != '/' && chr != '\\') continue;
             } else if (!stateOverride && chr == '?') {
               url.query = '';
-              state = QUERY;
+              state = QUERY$1;
             } else if (!stateOverride && chr == '#') {
               url.fragment = '';
               state = FRAGMENT;
@@ -4191,7 +4191,7 @@
               }
               if (chr == '?') {
                 url.query = '';
-                state = QUERY;
+                state = QUERY$1;
               } else if (chr == '#') {
                 url.fragment = '';
                 state = FRAGMENT;
@@ -4203,7 +4203,7 @@
           case CANNOT_BE_A_BASE_URL_PATH:
             if (chr == '?') {
               url.query = '';
-              state = QUERY;
+              state = QUERY$1;
             } else if (chr == '#') {
               url.fragment = '';
               state = FRAGMENT;
@@ -4211,7 +4211,7 @@
               url.path[0] += percentEncode(chr, C0ControlPercentEncodeSet);
             } break;
 
-          case QUERY:
+          case QUERY$1:
             if (!stateOverride && chr == '#') {
               url.fragment = '';
               state = FRAGMENT;
@@ -4402,7 +4402,7 @@
       } else {
         if ('?' == charAt(search, 0)) search = stringSlice$1(search, 1);
         this.query = '';
-        this.parse(search, QUERY);
+        this.parse(search, QUERY$1);
       }
       this.searchParams.update();
     },
@@ -35825,6 +35825,419 @@
     }));
   };
 
+  function warning(condition, message) {
+  }
+
+  /**
+    * react-collapsed v4.2.0
+    *
+    * Copyright (c) 2019-2024, Rogin Farrer
+    *
+    * This source code is licensed under the MIT license found in the
+    * LICENSE.md file in the root directory of this source tree.
+    *
+    * @license MIT
+    */
+  var CollapseError = class extends Error {
+    constructor(message) {
+      super(`react-collapsed: ${message}`);
+    }
+  };
+  var collapseWarning = (...args) => {
+    return warning(args[0], `[react-collapsed] -- ${args[1]}`);
+  };
+  function useEvent(callback) {
+    const ref = React.useRef(callback);
+    React.useEffect(() => {
+      ref.current = callback;
+    });
+    return React.useCallback((...args) => ref.current?.(...args), []);
+  }
+  function useControlledState(value, defaultValue, callback) {
+    const [state, setState] = React.useState(defaultValue);
+    const initiallyControlled = React.useRef(typeof value !== "undefined");
+    const effectiveValue = initiallyControlled.current ? value : state;
+    const cb = useEvent(callback);
+    const onChange = React.useCallback(
+      (update) => {
+        const setter = update;
+        const newValue = typeof update === "function" ? setter(effectiveValue) : update;
+        if (!initiallyControlled.current) {
+          setState(newValue);
+        }
+        cb?.(newValue);
+      },
+      [cb, effectiveValue]
+    );
+    React.useEffect(() => {
+      collapseWarning(
+        !(initiallyControlled.current && value == null),
+        "`isExpanded` state is changing from controlled to uncontrolled. useCollapse should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled collapse for the lifetime of the component. Check the `isExpanded` prop."
+      );
+      collapseWarning(
+        !(!initiallyControlled.current && value != null),
+        "`isExpanded` state is changing from uncontrolled to controlled. useCollapse should not switch from uncontrolled to controlled (or vice versa). Decide between using a controlled or uncontrolled collapse for the lifetime of the component. Check the `isExpanded` prop."
+      );
+    }, [value]);
+    return [effectiveValue, onChange];
+  }
+  var QUERY = "(prefers-reduced-motion: reduce)";
+  function usePrefersReducedMotion() {
+    const [prefersReducedMotion, setPrefersReducedMotion] = React.useState(false);
+    React.useEffect(() => {
+      if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+        return;
+      }
+      const mediaQueryList = window.matchMedia(QUERY);
+      setPrefersReducedMotion(mediaQueryList.matches);
+      const listener = (event) => {
+        setPrefersReducedMotion(event.matches);
+      };
+      if (mediaQueryList.addEventListener) {
+        mediaQueryList.addEventListener("change", listener);
+        return () => {
+          mediaQueryList.removeEventListener("change", listener);
+        };
+      } else if (mediaQueryList.addListener) {
+        mediaQueryList.addListener(listener);
+        return () => {
+          mediaQueryList.removeListener(listener);
+        };
+      }
+      return void 0;
+    }, []);
+    return prefersReducedMotion;
+  }
+  var __useId = React__namespace["useId".toString()] || (() => void 0);
+  function useReactId() {
+    const id2 = __useId();
+    return id2 ?? "";
+  }
+  var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+  var serverHandoffComplete = false;
+  var id = 0;
+  var genId = () => ++id;
+  function useUniqueId(idFromProps) {
+    const initialId = idFromProps || (serverHandoffComplete ? genId() : null);
+    const [id2, setId] = React__namespace.useState(initialId);
+    useIsomorphicLayoutEffect(() => {
+      if (id2 === null) {
+        setId(genId());
+      }
+    }, []);
+    React__namespace.useEffect(() => {
+      if (serverHandoffComplete === false) {
+        serverHandoffComplete = true;
+      }
+    }, []);
+    return id2 != null ? String(id2) : void 0;
+  }
+  function useId(idOverride) {
+    const reactId = useReactId();
+    const uniqueId = useUniqueId(idOverride);
+    if (typeof idOverride === "string") {
+      return idOverride;
+    }
+    if (typeof reactId === "string") {
+      return reactId;
+    }
+    return uniqueId;
+  }
+
+  // src/utils/setAnimationTimeout.ts
+  function setAnimationTimeout(callback, timeout) {
+    const startTime = performance.now();
+    const frame = {};
+    function call() {
+      frame.id = requestAnimationFrame((now) => {
+        if (now - startTime > timeout) {
+          callback();
+        } else {
+          call();
+        }
+      });
+    }
+    call();
+    return frame;
+  }
+  function clearAnimationTimeout(frame) {
+    if (frame.id)
+      cancelAnimationFrame(frame.id);
+  }
+
+  // src/utils/index.ts
+  function getElementHeight(el) {
+    if (!el?.current) {
+      collapseWarning(
+        true,
+        `Was not able to find a ref to the collapse element via \`getCollapseProps\`. Ensure that the element exposes its \`ref\` prop. If it exposes the ref prop under a different name (like \`innerRef\`), use the \`refKey\` property to change it. Example:
+
+const collapseProps = getCollapseProps({refKey: 'innerRef'})`
+      );
+      return 0;
+    }
+    return el.current.scrollHeight;
+  }
+  function getAutoHeightDuration(height) {
+    if (!height || typeof height === "string") {
+      return 0;
+    }
+    const constant = height / 36;
+    return Math.round((4 + 15 * constant ** 0.25 + constant / 5) * 10);
+  }
+  function assignRef(ref, value) {
+    if (ref == null)
+      return;
+    if (typeof ref === "function") {
+      ref(value);
+    } else {
+      try {
+        ref.current = value;
+      } catch (error) {
+        throw new CollapseError(`Cannot assign value "${value}" to ref "${ref}"`);
+      }
+    }
+  }
+  function mergeRefs(...refs) {
+    if (refs.every((ref) => ref == null)) {
+      return null;
+    }
+    return (node) => {
+      refs.forEach((ref) => {
+        assignRef(ref, node);
+      });
+    };
+  }
+  function usePaddingWarning(element) {
+    let warn = (el) => {
+    };
+    {
+      warn = (el) => {
+        if (!el?.current) {
+          return;
+        }
+        const { paddingTop, paddingBottom } = window.getComputedStyle(el.current);
+        const hasPadding = paddingTop && paddingTop !== "0px" || paddingBottom && paddingBottom !== "0px";
+        collapseWarning(
+          !hasPadding,
+          `Padding applied to the collapse element will cause the animation to break and not perform as expected. To fix, apply equivalent padding to the direct descendent of the collapse element. Example:
+
+Before:   <div {...getCollapseProps({style: {padding: 10}})}>{children}</div>
+
+After:   <div {...getCollapseProps()}>
+             <div style={{padding: 10}}>
+                 {children}
+             </div>
+          </div>`
+        );
+      };
+    }
+    React.useEffect(() => {
+      warn(element);
+    }, [element]);
+  }
+
+  // src/index.ts
+  var useLayoutEffect2 = typeof window === "undefined" ? React.useEffect : React.useLayoutEffect;
+  function useCollapse({
+    duration,
+    easing = "cubic-bezier(0.4, 0, 0.2, 1)",
+    onTransitionStateChange: propOnTransitionStateChange = () => {
+    },
+    isExpanded: configIsExpanded,
+    defaultExpanded = false,
+    hasDisabledAnimation,
+    id: id2,
+    ...initialConfig
+  } = {}) {
+    const onTransitionStateChange = useEvent(propOnTransitionStateChange);
+    const uniqueId = useId(id2 ? `${id2}` : void 0);
+    const [isExpanded, setExpanded] = useControlledState(
+      configIsExpanded,
+      defaultExpanded
+    );
+    const prevExpanded = React.useRef(isExpanded);
+    const [isAnimating, setIsAnimating] = React.useState(false);
+    const prefersReducedMotion = usePrefersReducedMotion();
+    const disableAnimation = hasDisabledAnimation ?? prefersReducedMotion;
+    const frameId = React.useRef();
+    const endFrameId = React.useRef();
+    const collapseElRef = React.useRef(null);
+    const [toggleEl, setToggleEl] = React.useState(null);
+    usePaddingWarning(collapseElRef);
+    const collapsedHeight = `${initialConfig.collapsedHeight || 0}px`;
+    function setStyles(newStyles) {
+      if (!collapseElRef.current)
+        return;
+      const target = collapseElRef.current;
+      for (const property in newStyles) {
+        const value = newStyles[property];
+        if (value) {
+          target.style[property] = value;
+        } else {
+          target.style.removeProperty(property);
+        }
+      }
+    }
+    useLayoutEffect2(() => {
+      const collapse = collapseElRef.current;
+      if (!collapse)
+        return;
+      if (isExpanded === prevExpanded.current)
+        return;
+      prevExpanded.current = isExpanded;
+      function getDuration(height) {
+        if (disableAnimation) {
+          return 0;
+        }
+        return duration ?? getAutoHeightDuration(height);
+      }
+      const getTransitionStyles = (height) => `height ${getDuration(height)}ms ${easing}`;
+      const setTransitionEndTimeout = (duration2) => {
+        function endTransition() {
+          if (isExpanded) {
+            setStyles({
+              height: "",
+              overflow: "",
+              transition: "",
+              display: ""
+            });
+            onTransitionStateChange("expandEnd");
+          } else {
+            setStyles({ transition: "" });
+            onTransitionStateChange("collapseEnd");
+          }
+          setIsAnimating(false);
+        }
+        if (endFrameId.current) {
+          clearAnimationTimeout(endFrameId.current);
+        }
+        endFrameId.current = setAnimationTimeout(endTransition, duration2);
+      };
+      setIsAnimating(true);
+      if (isExpanded) {
+        frameId.current = requestAnimationFrame(() => {
+          onTransitionStateChange("expandStart");
+          setStyles({
+            display: "block",
+            overflow: "hidden",
+            height: collapsedHeight
+          });
+          frameId.current = requestAnimationFrame(() => {
+            onTransitionStateChange("expanding");
+            const height = getElementHeight(collapseElRef);
+            setTransitionEndTimeout(getDuration(height));
+            if (collapseElRef.current) {
+              collapseElRef.current.style.transition = getTransitionStyles(height);
+              collapseElRef.current.style.height = `${height}px`;
+            }
+          });
+        });
+      } else {
+        frameId.current = requestAnimationFrame(() => {
+          onTransitionStateChange("collapseStart");
+          const height = getElementHeight(collapseElRef);
+          setTransitionEndTimeout(getDuration(height));
+          setStyles({
+            transition: getTransitionStyles(height),
+            height: `${height}px`
+          });
+          frameId.current = requestAnimationFrame(() => {
+            onTransitionStateChange("collapsing");
+            setStyles({
+              height: collapsedHeight,
+              overflow: "hidden"
+            });
+          });
+        });
+      }
+      return () => {
+        if (frameId.current)
+          cancelAnimationFrame(frameId.current);
+        if (endFrameId.current)
+          clearAnimationTimeout(endFrameId.current);
+      };
+    }, [
+      isExpanded,
+      collapsedHeight,
+      disableAnimation,
+      duration,
+      easing,
+      onTransitionStateChange
+    ]);
+    return {
+      isExpanded,
+      setExpanded,
+      getToggleProps(args) {
+        const { disabled, onClick, refKey, ...rest } = {
+          refKey: "ref",
+          onClick() {
+          },
+          disabled: false,
+          ...args
+        };
+        const isButton = toggleEl ? toggleEl.tagName === "BUTTON" : void 0;
+        const theirRef = args?.[refKey || "ref"];
+        const props = {
+          id: `react-collapsed-toggle-${uniqueId}`,
+          "aria-controls": `react-collapsed-panel-${uniqueId}`,
+          "aria-expanded": isExpanded,
+          onClick(evt) {
+            if (disabled)
+              return;
+            onClick?.(evt);
+            setExpanded((n) => !n);
+          },
+          [refKey || "ref"]: mergeRefs(theirRef, setToggleEl)
+        };
+        const buttonProps = {
+          type: "button",
+          disabled: disabled ? true : void 0
+        };
+        const fakeButtonProps = {
+          "aria-disabled": disabled ? true : void 0,
+          role: "button",
+          tabIndex: disabled ? -1 : 0
+        };
+        if (isButton === false) {
+          return { ...props, ...fakeButtonProps, ...rest };
+        } else if (isButton === true) {
+          return { ...props, ...buttonProps, ...rest };
+        } else {
+          return {
+            ...props,
+            ...buttonProps,
+            ...fakeButtonProps,
+            ...rest
+          };
+        }
+      },
+      getCollapseProps(args) {
+        const { style, refKey } = { refKey: "ref", style: {}, ...args };
+        const theirRef = args?.[refKey || "ref"];
+        return {
+          id: `react-collapsed-panel-${uniqueId}`,
+          "aria-hidden": !isExpanded,
+          "aria-labelledby": `react-collapsed-toggle-${uniqueId}`,
+          role: "region",
+          ...args,
+          [refKey || "ref"]: mergeRefs(collapseElRef, theirRef),
+          style: {
+            boxSizing: "border-box",
+            ...!isAnimating && !isExpanded ? {
+              // collapsed and not animating
+              display: collapsedHeight === "0px" ? "none" : "block",
+              height: collapsedHeight,
+              overflow: "hidden"
+            } : {},
+            // additional styles passed, e.g. getCollapseProps({style: {}})
+            ...style
+          }
+        };
+      }
+    };
+  }
+
   var Wrapper = styled__default["default"].div.withConfig({
     displayName: "styles__Wrapper",
     componentId: "sc-mlx2bu-0"
@@ -35914,7 +36327,7 @@
       return (_collapseState$state = collapseState[state]) === null || _collapseState$state === void 0 ? void 0 : _collapseState$state.call(collapseState);
     };
 
-    var _useCollapse = reactCollapsed.useCollapse({
+    var _useCollapse = useCollapse({
       isExpanded: isOpenState,
       onTransitionStateChange: function onTransitionStateChange(state) {
         return !disabled && triggerHandler(state);