@blockend/widget 1.0.31 → 1.0.32

package/dist/index-BxHeZ9IF.js

@@ -1,543 +0,0 @@
-import { g as generateUtilityClass, p as process$1, r as resolveProps, _ as _objectWithoutPropertiesLoose, b as _extends, d as capitalize, e as colorManipulatorExports, P as PropTypes } from "./index-D5OnT-__.js";
-import * as React from "react";
-import { g as generateUtilityClasses, d as useDefaultProps, s as styled, c as clsx, a as composeClasses, r as rootShouldForwardProp } from "./useRegisterError-W_UfecIN.js";
-import { jsx, jsxs } from "react/jsx-runtime";
-import { B as ButtonBase } from "./getChainIds-6iugk2h0.js";
-function getButtonUtilityClass(slot) {
-  return generateUtilityClass("MuiButton", slot);
-}
-const buttonClasses = generateUtilityClasses("MuiButton", ["root", "text", "textInherit", "textPrimary", "textSecondary", "textSuccess", "textError", "textInfo", "textWarning", "outlined", "outlinedInherit", "outlinedPrimary", "outlinedSecondary", "outlinedSuccess", "outlinedError", "outlinedInfo", "outlinedWarning", "contained", "containedInherit", "containedPrimary", "containedSecondary", "containedSuccess", "containedError", "containedInfo", "containedWarning", "disableElevation", "focusVisible", "disabled", "colorInherit", "colorPrimary", "colorSecondary", "colorSuccess", "colorError", "colorInfo", "colorWarning", "textSizeSmall", "textSizeMedium", "textSizeLarge", "outlinedSizeSmall", "outlinedSizeMedium", "outlinedSizeLarge", "containedSizeSmall", "containedSizeMedium", "containedSizeLarge", "sizeMedium", "sizeSmall", "sizeLarge", "fullWidth", "startIcon", "endIcon", "icon", "iconSizeSmall", "iconSizeMedium", "iconSizeLarge"]);
-const ButtonGroupContext = /* @__PURE__ */ React.createContext({});
-if (process$1.env.NODE_ENV !== "production") {
-  ButtonGroupContext.displayName = "ButtonGroupContext";
-}
-const ButtonGroupButtonContext = /* @__PURE__ */ React.createContext(void 0);
-if (process$1.env.NODE_ENV !== "production") {
-  ButtonGroupButtonContext.displayName = "ButtonGroupButtonContext";
-}
-const _excluded = ["children", "color", "component", "className", "disabled", "disableElevation", "disableFocusRipple", "endIcon", "focusVisibleClassName", "fullWidth", "size", "startIcon", "type", "variant"];
-const useUtilityClasses = (ownerState) => {
-  const {
-    color,
-    disableElevation,
-    fullWidth,
-    size,
-    variant,
-    classes
-  } = ownerState;
-  const slots = {
-    root: ["root", variant, `${variant}${capitalize(color)}`, `size${capitalize(size)}`, `${variant}Size${capitalize(size)}`, `color${capitalize(color)}`, disableElevation && "disableElevation", fullWidth && "fullWidth"],
-    label: ["label"],
-    startIcon: ["icon", "startIcon", `iconSize${capitalize(size)}`],
-    endIcon: ["icon", "endIcon", `iconSize${capitalize(size)}`]
-  };
-  const composedClasses = composeClasses(slots, getButtonUtilityClass, classes);
-  return _extends({}, classes, composedClasses);
-};
-const commonIconStyles = (ownerState) => _extends({}, ownerState.size === "small" && {
-  "& > *:nth-of-type(1)": {
-    fontSize: 18
-  }
-}, ownerState.size === "medium" && {
-  "& > *:nth-of-type(1)": {
-    fontSize: 20
-  }
-}, ownerState.size === "large" && {
-  "& > *:nth-of-type(1)": {
-    fontSize: 22
-  }
-});
-const ButtonRoot = styled(ButtonBase, {
-  shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes",
-  name: "MuiButton",
-  slot: "Root",
-  overridesResolver: (props, styles) => {
-    const {
-      ownerState
-    } = props;
-    return [styles.root, styles[ownerState.variant], styles[`${ownerState.variant}${capitalize(ownerState.color)}`], styles[`size${capitalize(ownerState.size)}`], styles[`${ownerState.variant}Size${capitalize(ownerState.size)}`], ownerState.color === "inherit" && styles.colorInherit, ownerState.disableElevation && styles.disableElevation, ownerState.fullWidth && styles.fullWidth];
-  }
-})(({
-  theme,
-  ownerState
-}) => {
-  var _theme$palette$getCon, _theme$palette;
-  const inheritContainedBackgroundColor = theme.palette.mode === "light" ? theme.palette.grey[300] : theme.palette.grey[800];
-  const inheritContainedHoverBackgroundColor = theme.palette.mode === "light" ? theme.palette.grey.A100 : theme.palette.grey[700];
-  return _extends({}, theme.typography.button, {
-    minWidth: 64,
-    padding: "6px 16px",
-    borderRadius: (theme.vars || theme).shape.borderRadius,
-    transition: theme.transitions.create(["background-color", "box-shadow", "border-color", "color"], {
-      duration: theme.transitions.duration.short
-    }),
-    "&:hover": _extends({
-      textDecoration: "none",
-      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.text.primaryChannel} / ${theme.vars.palette.action.hoverOpacity})` : colorManipulatorExports.alpha(theme.palette.text.primary, theme.palette.action.hoverOpacity),
-      // Reset on touch devices, it doesn't add specificity
-      "@media (hover: none)": {
-        backgroundColor: "transparent"
-      }
-    }, ownerState.variant === "text" && ownerState.color !== "inherit" && {
-      backgroundColor: theme.vars ? `rgba(${theme.vars.palette[ownerState.color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : colorManipulatorExports.alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
-      // Reset on touch devices, it doesn't add specificity
-      "@media (hover: none)": {
-        backgroundColor: "transparent"
-      }
-    }, ownerState.variant === "outlined" && ownerState.color !== "inherit" && {
-      border: `1px solid ${(theme.vars || theme).palette[ownerState.color].main}`,
-      backgroundColor: theme.vars ? `rgba(${theme.vars.palette[ownerState.color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : colorManipulatorExports.alpha(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity),
-      // Reset on touch devices, it doesn't add specificity
-      "@media (hover: none)": {
-        backgroundColor: "transparent"
-      }
-    }, ownerState.variant === "contained" && {
-      backgroundColor: theme.vars ? theme.vars.palette.Button.inheritContainedHoverBg : inheritContainedHoverBackgroundColor,
-      boxShadow: (theme.vars || theme).shadows[4],
-      // Reset on touch devices, it doesn't add specificity
-      "@media (hover: none)": {
-        boxShadow: (theme.vars || theme).shadows[2],
-        backgroundColor: (theme.vars || theme).palette.grey[300]
-      }
-    }, ownerState.variant === "contained" && ownerState.color !== "inherit" && {
-      backgroundColor: (theme.vars || theme).palette[ownerState.color].dark,
-      // Reset on touch devices, it doesn't add specificity
-      "@media (hover: none)": {
-        backgroundColor: (theme.vars || theme).palette[ownerState.color].main
-      }
-    }),
-    "&:active": _extends({}, ownerState.variant === "contained" && {
-      boxShadow: (theme.vars || theme).shadows[8]
-    }),
-    [`&.${buttonClasses.focusVisible}`]: _extends({}, ownerState.variant === "contained" && {
-      boxShadow: (theme.vars || theme).shadows[6]
-    }),
-    [`&.${buttonClasses.disabled}`]: _extends({
-      color: (theme.vars || theme).palette.action.disabled
-    }, ownerState.variant === "outlined" && {
-      border: `1px solid ${(theme.vars || theme).palette.action.disabledBackground}`
-    }, ownerState.variant === "contained" && {
-      color: (theme.vars || theme).palette.action.disabled,
-      boxShadow: (theme.vars || theme).shadows[0],
-      backgroundColor: (theme.vars || theme).palette.action.disabledBackground
-    })
-  }, ownerState.variant === "text" && {
-    padding: "6px 8px"
-  }, ownerState.variant === "text" && ownerState.color !== "inherit" && {
-    color: (theme.vars || theme).palette[ownerState.color].main
-  }, ownerState.variant === "outlined" && {
-    padding: "5px 15px",
-    border: "1px solid currentColor"
-  }, ownerState.variant === "outlined" && ownerState.color !== "inherit" && {
-    color: (theme.vars || theme).palette[ownerState.color].main,
-    border: theme.vars ? `1px solid rgba(${theme.vars.palette[ownerState.color].mainChannel} / 0.5)` : `1px solid ${colorManipulatorExports.alpha(theme.palette[ownerState.color].main, 0.5)}`
-  }, ownerState.variant === "contained" && {
-    color: theme.vars ? (
-      // this is safe because grey does not change between default light/dark mode
-      theme.vars.palette.text.primary
-    ) : (_theme$palette$getCon = (_theme$palette = theme.palette).getContrastText) == null ? void 0 : _theme$palette$getCon.call(_theme$palette, theme.palette.grey[300]),
-    backgroundColor: theme.vars ? theme.vars.palette.Button.inheritContainedBg : inheritContainedBackgroundColor,
-    boxShadow: (theme.vars || theme).shadows[2]
-  }, ownerState.variant === "contained" && ownerState.color !== "inherit" && {
-    color: (theme.vars || theme).palette[ownerState.color].contrastText,
-    backgroundColor: (theme.vars || theme).palette[ownerState.color].main
-  }, ownerState.color === "inherit" && {
-    color: "inherit",
-    borderColor: "currentColor"
-  }, ownerState.size === "small" && ownerState.variant === "text" && {
-    padding: "4px 5px",
-    fontSize: theme.typography.pxToRem(13)
-  }, ownerState.size === "large" && ownerState.variant === "text" && {
-    padding: "8px 11px",
-    fontSize: theme.typography.pxToRem(15)
-  }, ownerState.size === "small" && ownerState.variant === "outlined" && {
-    padding: "3px 9px",
-    fontSize: theme.typography.pxToRem(13)
-  }, ownerState.size === "large" && ownerState.variant === "outlined" && {
-    padding: "7px 21px",
-    fontSize: theme.typography.pxToRem(15)
-  }, ownerState.size === "small" && ownerState.variant === "contained" && {
-    padding: "4px 10px",
-    fontSize: theme.typography.pxToRem(13)
-  }, ownerState.size === "large" && ownerState.variant === "contained" && {
-    padding: "8px 22px",
-    fontSize: theme.typography.pxToRem(15)
-  }, ownerState.fullWidth && {
-    width: "100%"
-  });
-}, ({
-  ownerState
-}) => ownerState.disableElevation && {
-  boxShadow: "none",
-  "&:hover": {
-    boxShadow: "none"
-  },
-  [`&.${buttonClasses.focusVisible}`]: {
-    boxShadow: "none"
-  },
-  "&:active": {
-    boxShadow: "none"
-  },
-  [`&.${buttonClasses.disabled}`]: {
-    boxShadow: "none"
-  }
-});
-const ButtonStartIcon = styled("span", {
-  name: "MuiButton",
-  slot: "StartIcon",
-  overridesResolver: (props, styles) => {
-    const {
-      ownerState
-    } = props;
-    return [styles.startIcon, styles[`iconSize${capitalize(ownerState.size)}`]];
-  }
-})(({
-  ownerState
-}) => _extends({
-  display: "inherit",
-  marginRight: 8,
-  marginLeft: -4
-}, ownerState.size === "small" && {
-  marginLeft: -2
-}, commonIconStyles(ownerState)));
-const ButtonEndIcon = styled("span", {
-  name: "MuiButton",
-  slot: "EndIcon",
-  overridesResolver: (props, styles) => {
-    const {
-      ownerState
-    } = props;
-    return [styles.endIcon, styles[`iconSize${capitalize(ownerState.size)}`]];
-  }
-})(({
-  ownerState
-}) => _extends({
-  display: "inherit",
-  marginRight: -4,
-  marginLeft: 8
-}, ownerState.size === "small" && {
-  marginRight: -2
-}, commonIconStyles(ownerState)));
-const Button = /* @__PURE__ */ React.forwardRef(function Button2(inProps, ref) {
-  const contextProps = React.useContext(ButtonGroupContext);
-  const buttonGroupButtonContextPositionClassName = React.useContext(ButtonGroupButtonContext);
-  const resolvedProps = resolveProps(contextProps, inProps);
-  const props = useDefaultProps({
-    props: resolvedProps,
-    name: "MuiButton"
-  });
-  const {
-    children,
-    color = "primary",
-    component = "button",
-    className,
-    disabled = false,
-    disableElevation = false,
-    disableFocusRipple = false,
-    endIcon: endIconProp,
-    focusVisibleClassName,
-    fullWidth = false,
-    size = "medium",
-    startIcon: startIconProp,
-    type,
-    variant = "text"
-  } = props, other = _objectWithoutPropertiesLoose(props, _excluded);
-  const ownerState = _extends({}, props, {
-    color,
-    component,
-    disabled,
-    disableElevation,
-    disableFocusRipple,
-    fullWidth,
-    size,
-    type,
-    variant
-  });
-  const classes = useUtilityClasses(ownerState);
-  const startIcon = startIconProp && /* @__PURE__ */ jsx(ButtonStartIcon, {
-    className: classes.startIcon,
-    ownerState,
-    children: startIconProp
-  });
-  const endIcon = endIconProp && /* @__PURE__ */ jsx(ButtonEndIcon, {
-    className: classes.endIcon,
-    ownerState,
-    children: endIconProp
-  });
-  const positionClassName = buttonGroupButtonContextPositionClassName || "";
-  return /* @__PURE__ */ jsxs(ButtonRoot, _extends({
-    ownerState,
-    className: clsx(contextProps.className, classes.root, className, positionClassName),
-    component,
-    disabled,
-    focusRipple: !disableFocusRipple,
-    focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
-    ref,
-    type
-  }, other, {
-    classes,
-    children: [startIcon, children, endIcon]
-  }));
-});
-process$1.env.NODE_ENV !== "production" ? Button.propTypes = {
-  // ┌────────────────────────────── Warning ──────────────────────────────┐
-  // │ These PropTypes are generated from the TypeScript type definitions. │
-  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
-  // └─────────────────────────────────────────────────────────────────────┘
-  /**
-   * The content of the component.
-   */
-  children: PropTypes.node,
-  /**
-   * Override or extend the styles applied to the component.
-   */
-  classes: PropTypes.object,
-  /**
-   * @ignore
-   */
-  className: PropTypes.string,
-  /**
-   * The color of the component.
-   * It supports both default and custom theme colors, which can be added as shown in the
-   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
-   * @default 'primary'
-   */
-  color: PropTypes.oneOfType([PropTypes.oneOf(["inherit", "primary", "secondary", "success", "error", "info", "warning"]), PropTypes.string]),
-  /**
-   * The component used for the root node.
-   * Either a string to use a HTML element or a component.
-   */
-  component: PropTypes.elementType,
-  /**
-   * If `true`, the component is disabled.
-   * @default false
-   */
-  disabled: PropTypes.bool,
-  /**
-   * If `true`, no elevation is used.
-   * @default false
-   */
-  disableElevation: PropTypes.bool,
-  /**
-   * If `true`, the  keyboard focus ripple is disabled.
-   * @default false
-   */
-  disableFocusRipple: PropTypes.bool,
-  /**
-   * If `true`, the ripple effect is disabled.
-   *
-   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
-   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
-   * @default false
-   */
-  disableRipple: PropTypes.bool,
-  /**
-   * Element placed after the children.
-   */
-  endIcon: PropTypes.node,
-  /**
-   * @ignore
-   */
-  focusVisibleClassName: PropTypes.string,
-  /**
-   * If `true`, the button will take up the full width of its container.
-   * @default false
-   */
-  fullWidth: PropTypes.bool,
-  /**
-   * The URL to link to when the button is clicked.
-   * If defined, an `a` element will be used as the root node.
-   */
-  href: PropTypes.string,
-  /**
-   * The size of the component.
-   * `small` is equivalent to the dense button styling.
-   * @default 'medium'
-   */
-  size: PropTypes.oneOfType([PropTypes.oneOf(["small", "medium", "large"]), PropTypes.string]),
-  /**
-   * Element placed before the children.
-   */
-  startIcon: PropTypes.node,
-  /**
-   * The system prop that allows defining system overrides as well as additional CSS styles.
-   */
-  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
-  /**
-   * @ignore
-   */
-  type: PropTypes.oneOfType([PropTypes.oneOf(["button", "reset", "submit"]), PropTypes.string]),
-  /**
-   * The variant to use.
-   * @default 'text'
-   */
-  variant: PropTypes.oneOfType([PropTypes.oneOf(["contained", "outlined", "text"]), PropTypes.string])
-} : void 0;
-var observerMap = /* @__PURE__ */ new Map();
-var RootIds = /* @__PURE__ */ new WeakMap();
-var rootId = 0;
-var unsupportedValue = void 0;
-function getRootId(root) {
-  if (!root) return "0";
-  if (RootIds.has(root)) return RootIds.get(root);
-  rootId += 1;
-  RootIds.set(root, rootId.toString());
-  return RootIds.get(root);
-}
-function optionsToId(options) {
-  return Object.keys(options).sort().filter(
-    (key) => options[key] !== void 0
-  ).map((key) => {
-    return `${key}_${key === "root" ? getRootId(options.root) : options[key]}`;
-  }).toString();
-}
-function createObserver(options) {
-  const id = optionsToId(options);
-  let instance = observerMap.get(id);
-  if (!instance) {
-    const elements = /* @__PURE__ */ new Map();
-    let thresholds;
-    const observer = new IntersectionObserver((entries) => {
-      entries.forEach((entry) => {
-        var _a;
-        const inView = entry.isIntersecting && thresholds.some((threshold) => entry.intersectionRatio >= threshold);
-        if (options.trackVisibility && typeof entry.isVisible === "undefined") {
-          entry.isVisible = inView;
-        }
-        (_a = elements.get(entry.target)) == null ? void 0 : _a.forEach((callback) => {
-          callback(inView, entry);
-        });
-      });
-    }, options);
-    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);
-    instance = {
-      id,
-      observer,
-      elements
-    };
-    observerMap.set(id, instance);
-  }
-  return instance;
-}
-function observe(element, callback, options = {}, fallbackInView = unsupportedValue) {
-  if (typeof window.IntersectionObserver === "undefined" && fallbackInView !== void 0) {
-    const bounds = element.getBoundingClientRect();
-    callback(fallbackInView, {
-      isIntersecting: fallbackInView,
-      target: element,
-      intersectionRatio: typeof options.threshold === "number" ? options.threshold : 0,
-      time: 0,
-      boundingClientRect: bounds,
-      intersectionRect: bounds,
-      rootBounds: bounds
-    });
-    return () => {
-    };
-  }
-  const { id, observer, elements } = createObserver(options);
-  const callbacks = elements.get(element) || [];
-  if (!elements.has(element)) {
-    elements.set(element, callbacks);
-  }
-  callbacks.push(callback);
-  observer.observe(element);
-  return function unobserve() {
-    callbacks.splice(callbacks.indexOf(callback), 1);
-    if (callbacks.length === 0) {
-      elements.delete(element);
-      observer.unobserve(element);
-    }
-    if (elements.size === 0) {
-      observer.disconnect();
-      observerMap.delete(id);
-    }
-  };
-}
-function useInView({
-  threshold,
-  delay,
-  trackVisibility,
-  rootMargin,
-  root,
-  triggerOnce,
-  skip,
-  initialInView,
-  fallbackInView,
-  onChange
-} = {}) {
-  var _a;
-  const [ref, setRef] = React.useState(null);
-  const callback = React.useRef(onChange);
-  const [state, setState] = React.useState({
-    inView: !!initialInView,
-    entry: void 0
-  });
-  callback.current = onChange;
-  React.useEffect(
-    () => {
-      if (skip || !ref) return;
-      let unobserve;
-      unobserve = observe(
-        ref,
-        (inView, entry) => {
-          setState({
-            inView,
-            entry
-          });
-          if (callback.current) callback.current(inView, entry);
-          if (entry.isIntersecting && triggerOnce && unobserve) {
-            unobserve();
-            unobserve = void 0;
-          }
-        },
-        {
-          root,
-          rootMargin,
-          threshold,
-          // @ts-ignore
-          trackVisibility,
-          // @ts-ignore
-          delay
-        },
-        fallbackInView
-      );
-      return () => {
-        if (unobserve) {
-          unobserve();
-        }
-      };
-    },
-    // We break the rule here, because we aren't including the actual `threshold` variable
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      // If the threshold is an array, convert it to a string, so it won't change between renders.
-      Array.isArray(threshold) ? threshold.toString() : threshold,
-      ref,
-      root,
-      rootMargin,
-      triggerOnce,
-      skip,
-      trackVisibility,
-      fallbackInView,
-      delay
-    ]
-  );
-  const entryTarget = (_a = state.entry) == null ? void 0 : _a.target;
-  const previousEntryTarget = React.useRef(void 0);
-  if (!ref && entryTarget && !triggerOnce && !skip && previousEntryTarget.current !== entryTarget) {
-    previousEntryTarget.current = entryTarget;
-    setState({
-      inView: !!initialInView,
-      entry: void 0
-    });
-  }
-  const result = [setRef, state.inView, state.entry];
-  result.ref = result[0];
-  result.inView = result[1];
-  result.entry = result[2];
-  return result;
-}
-export {
-  Button as B,
-  useInView as u
-};