@m4l/components 3.1.7 → 3.1.8

package/components/GridLayout/subcomponents/Responsive/index-BKcU2OnF.js

@@ -1,348 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { r as cloneLayoutItem, t as cloneLayout, u as compact, v as correctBounds, w as isEqualLayout, o as DEFAULT_COLAPSED_HEIGHT, x as DEFAULT_RESPONSIVE_BREAKPOINTS, m as DEFAULT_CONTAINER_PADDING, l as DEFAULT_MARGIN, y as DEFAULT_RESPONSIVE_COLS, i as DEFAULT_ROW_HEIGHT, z as isEqualLayouts, G as GridLayout, A as noop } from "../../index-C4HyxNYX.js";
-import { useState, useRef, useEffect, useCallback } from "react";
-import { useFirstRender } from "@m4l/graphics";
-import { deepEqual } from "fast-equals";
-function getBreakpointFromWidth(breakpoints, width) {
-  const sorted = sortBreakpoints(breakpoints);
-  let matching = sorted[0];
-  for (let i = 1, len = sorted.length; i < len; i++) {
-    const breakpointName = sorted[i];
-    if (width > breakpoints[breakpointName]) matching = breakpointName;
-  }
-  return matching;
-}
-function getColsFromBreakpoint(breakpoint, cols) {
-  if (!cols[breakpoint]) {
-    throw new Error(
-      "ResponsiveReactGridLayout: `cols` entry for breakpoint " + breakpoint + " is missing!"
-    );
-  }
-  return cols[breakpoint];
-}
-function findOrGenerateResponsiveLayout(layouts, breakpoints, breakpoint, lastBreakpoint, cols, compactType, brekpointsCols, colapsedHeight, rowHeight) {
-  let layout = layouts[breakpoint];
-  const breakpointsSorted = sortBreakpoints(breakpoints);
-  const indexBreakointInit = breakpointsSorted.indexOf(breakpoint);
-  let compareBreakpoint;
-  if (!layout) {
-    if (lastBreakpoint !== breakpoint && layouts[lastBreakpoint]) {
-      compareBreakpoint = lastBreakpoint;
-    } else {
-      const rotatedBreakpoints = [
-        ...breakpointsSorted.splice(indexBreakointInit),
-        ...breakpointsSorted.reverse()
-      ];
-      for (let i = 0, len = rotatedBreakpoints.length; i < len; i++) {
-        const b = rotatedBreakpoints[i];
-        if (layouts[b]) {
-          compareBreakpoint = b;
-          break;
-        }
-      }
-    }
-    if (compareBreakpoint) {
-      layout = [];
-      for (let i = 0, len = layouts[compareBreakpoint].length; i < len; i++) {
-        const li = cloneLayoutItem(layouts[compareBreakpoint][i]);
-        if (brekpointsCols[compareBreakpoint]) {
-          const newW = Math.round(li.w * cols / brekpointsCols[compareBreakpoint]);
-          li.w = newW;
-        }
-        layout.push(li);
-      }
-    }
-    if (!layout) {
-      layout = [];
-    }
-  } else {
-    layout = cloneLayout(layout);
-  }
-  layout = cloneLayout(layout);
-  const ret = compact(
-    correctBounds(layout, { cols }, colapsedHeight, colapsedHeight),
-    compactType,
-    cols,
-    colapsedHeight,
-    rowHeight
-  );
-  return ret;
-}
-function sortBreakpoints(breakpoints) {
-  const keys = Object.keys(breakpoints);
-  return keys.sort(function(a, b) {
-    return breakpoints[a] - breakpoints[b];
-  });
-}
-function getIndentationValue(param, breakpoint) {
-  if (!param) return [0, 0];
-  return Array.isArray(param) ? param : param[breakpoint];
-}
-function addLayoutItemToBreakPointIfNoExists(layouts, breakpoint, layoutItem, cols, margin, containerPadding, rowHeight, containerHeight, currentBreakpoint) {
-  if (!layouts[breakpoint]) return;
-  if (layouts[breakpoint].findIndex((l) => l.i === layoutItem.i) === -1) {
-    const l = cloneLayoutItem(layoutItem);
-    const rowHeightBreakpoint = typeof rowHeight === "number" ? rowHeight : rowHeight[breakpoint];
-    const heigthUnits = containerHeight !== void 0 ? (containerHeight + getIndentationValue(margin, breakpoint)[1] - 2 * getIndentationValue(containerPadding, breakpoint)[1]) / (rowHeightBreakpoint + getIndentationValue(margin, breakpoint)[1]) : l.h;
-    if (l.freeMove) {
-      l.x = Math.round(cols[breakpoint] / 4);
-      l.y = Math.round(heigthUnits / 4);
-      l.w = Math.round(cols[breakpoint] / 2);
-      l.h = heigthUnits / 2;
-      if (breakpoint === "xxs") {
-        l.visible = false;
-        for (let index = 0; index < layouts[breakpoint].length; index++) {
-          if (layouts[breakpoint][index].freeMove) {
-            layouts[breakpoint][index].visible = false;
-          }
-        }
-        if (currentBreakpoint === "xxs") {
-          l.visible = true;
-        }
-      }
-    } else {
-      l.w = cols[breakpoint];
-      l.h = Math.round(heigthUnits * 0.8);
-    }
-    if (l.freeMove) {
-      layouts[breakpoint].push(l);
-    } else {
-      layouts[breakpoint].unshift(l);
-    }
-  }
-}
-function addLayoutItemToBreakPoints(layouts, layoutItem, cols, margin, containerPadding, rowHeight, containerHeight, currentBreakpoint) {
-  const newLayouts = {};
-  for (const key in layouts) {
-    const layoutBreakpoint = cloneLayout(layouts[key]);
-    newLayouts[key] = layoutBreakpoint;
-    addLayoutItemToBreakPointIfNoExists(
-      newLayouts,
-      key,
-      layoutItem,
-      cols,
-      margin,
-      containerPadding,
-      rowHeight,
-      containerHeight,
-      currentBreakpoint
-    );
-  }
-  return newLayouts;
-}
-function cloneLayouts(layouts, layoutItemReplaceProps) {
-  const newLayouts = {};
-  for (const breakPoint in layouts) {
-    newLayouts[breakPoint] = cloneLayout(layouts[breakPoint], layoutItemReplaceProps);
-  }
-  return newLayouts;
-}
-function generateInitialState(props) {
-  const {
-    containerWidth,
-    breakpoint,
-    breakpoints = DEFAULT_RESPONSIVE_BREAKPOINTS,
-    containerPadding = DEFAULT_CONTAINER_PADDING,
-    containerMargin = DEFAULT_MARGIN,
-    layouts: defaultLayouts = {},
-    cols = DEFAULT_RESPONSIVE_COLS,
-    compactType = null,
-    colapsedHeight = DEFAULT_COLAPSED_HEIGHT,
-    rowHeight = DEFAULT_ROW_HEIGHT
-  } = props;
-  const newBreakpoint = breakpoint || getBreakpointFromWidth(breakpoints, containerWidth);
-  const newCols = getColsFromBreakpoint(newBreakpoint, cols);
-  let fireOnLoadLayoutChange = true;
-  const initialColapsedHeight = getHeight(colapsedHeight, newBreakpoint);
-  const initialrowHeight = getHeight(rowHeight, newBreakpoint);
-  const initialLayout = findOrGenerateResponsiveLayout(
-    defaultLayouts,
-    breakpoints,
-    newBreakpoint,
-    newBreakpoint,
-    newCols,
-    compactType,
-    { [newBreakpoint]: newCols },
-    initialColapsedHeight,
-    initialrowHeight
-  );
-  if (defaultLayouts[newBreakpoint]) {
-    if (isEqualLayout(defaultLayouts[newBreakpoint], initialLayout)) {
-      fireOnLoadLayoutChange = false;
-    }
-  }
-  const ret = {
-    breakpointLayout: initialLayout,
-    breakpoint: newBreakpoint,
-    cols: newCols,
-    contaierMargin: getIndentationValue(containerMargin, newBreakpoint),
-    contaierPadding: getIndentationValue(containerPadding, newBreakpoint),
-    fireOnLoadLayoutChange,
-    colapsedHeight: initialColapsedHeight,
-    rowHeight: initialrowHeight
-  };
-  return ret;
-}
-const getHeight = (objectOrHeight, currentBreakpoint) => {
-  if (typeof objectOrHeight == "number") {
-    return objectOrHeight;
-  }
-  if (objectOrHeight[currentBreakpoint]) {
-    return objectOrHeight[currentBreakpoint];
-  }
-  return DEFAULT_COLAPSED_HEIGHT;
-};
-function Responsive(props) {
-  const {
-    layoutItemRender,
-    containerWidth,
-    containerHeight,
-    breakpoint,
-    compactType = null,
-    breakpoints = DEFAULT_RESPONSIVE_BREAKPOINTS,
-    cols = DEFAULT_RESPONSIVE_COLS,
-    containerPadding = DEFAULT_CONTAINER_PADDING,
-    containerMargin = DEFAULT_MARGIN,
-    layouts = {},
-    // onBreakpointChange = noop,
-    onLayoutChange = noop,
-    onContainerChange = noop,
-    colapsedHeight = DEFAULT_COLAPSED_HEIGHT,
-    rowHeight = DEFAULT_ROW_HEIGHT,
-    ...other
-  } = props;
-  const [currentState, setCurrentState] = useState(
-    () => generateInitialState(props)
-  );
-  const refState = useRef({
-    layouts: {
-      ...layouts,
-      [currentState.breakpoint]: currentState.breakpointLayout
-    },
-    cols,
-    currentBreakpointCols: currentState.cols,
-    currentBreakpoint: currentState.breakpoint,
-    breakpoints,
-    containerWidth,
-    containerHeight,
-    colapsedHeight: currentState.colapsedHeight,
-    rowHeight: currentState.rowHeight
-  });
-  const isFirstRenderFull = useFirstRender([
-    containerWidth,
-    containerHeight,
-    layouts,
-    breakpoint,
-    breakpoints,
-    cols
-  ]);
-  const isFirstRenderBreakpointLayout = useFirstRender([currentState.breakpointLayout]);
-  useEffect(() => {
-    if (!isFirstRenderBreakpointLayout) {
-      onLayoutChange(currentState.breakpointLayout, refState.current.layouts);
-    }
-  }, [currentState.breakpointLayout]);
-  useEffect(() => {
-    if (isFirstRenderFull) {
-      onContainerChange({
-        containerWidth: refState.current.containerWidth,
-        containerHeight: refState.current.containerHeight,
-        breakpoint: currentState.breakpoint,
-        cols: currentState.cols
-      });
-      if (currentState.fireOnLoadLayoutChange) {
-        onLayoutChange(currentState.breakpointLayout, {
-          ...layouts,
-          [currentState.breakpoint]: currentState.breakpointLayout
-        });
-      }
-      return;
-    }
-    const lastBreakpoint = refState.current.currentBreakpoint;
-    const lastContainerWidth = refState.current.containerWidth;
-    const lastContainerHeight = refState.current.containerHeight;
-    const lastBreakpointCols = refState.current.currentBreakpointCols;
-    const newBreakpoint = breakpoint || getBreakpointFromWidth(breakpoints, containerWidth);
-    const newCols = getColsFromBreakpoint(newBreakpoint, cols);
-    const newLayouts = { ...layouts };
-    let newContainerMargin = currentState.contaierMargin;
-    let newContainerPadding = currentState.contaierPadding;
-    if (newBreakpoint !== lastBreakpoint || newCols !== lastBreakpointCols || !deepEqual(cols, refState.current.cols) || !deepEqual(breakpoints, refState.current.breakpoints) || !isEqualLayouts(layouts, refState.current.layouts)) {
-      newContainerMargin = getIndentationValue(containerMargin, newBreakpoint);
-      newContainerPadding = getIndentationValue(containerPadding, newBreakpoint);
-      const newColapsedHeight = getHeight(colapsedHeight, newBreakpoint);
-      const newRowHeight = getHeight(rowHeight, newBreakpoint);
-      if (!(lastBreakpoint in newLayouts)) {
-        console.error("useEffect casi imposible", lastBreakpoint, newLayouts);
-        newLayouts[lastBreakpoint] = cloneLayout(currentState.breakpointLayout);
-      }
-      const layout = findOrGenerateResponsiveLayout(
-        newLayouts,
-        breakpoints,
-        newBreakpoint,
-        lastBreakpoint,
-        newCols,
-        compactType,
-        cols,
-        newColapsedHeight,
-        newRowHeight
-      );
-      newLayouts[newBreakpoint] = layout;
-      refState.current.layouts = newLayouts;
-      refState.current.breakpoints = breakpoints;
-      refState.current.currentBreakpoint = newBreakpoint;
-      refState.current.currentBreakpointCols = newCols;
-      refState.current.colapsedHeight = newColapsedHeight;
-      setCurrentState({
-        breakpoint: newBreakpoint,
-        breakpointLayout: layout,
-        cols: newCols,
-        contaierMargin: newContainerMargin,
-        contaierPadding: newContainerPadding,
-        colapsedHeight: newColapsedHeight,
-        rowHeight: newRowHeight
-      });
-    }
-    if (newBreakpoint !== lastBreakpoint || newCols !== lastBreakpointCols || lastContainerWidth !== containerWidth || lastContainerHeight != containerHeight) {
-      onContainerChange({
-        containerWidth,
-        containerHeight,
-        // containerMargin: newContainerMargin,
-        // containerPadding: newContainerPadding,
-        breakpoint: newBreakpoint,
-        cols: newCols
-      });
-    }
-  }, [containerWidth, containerHeight, layouts, breakpoint, breakpoints, cols]);
-  const localOnLayoutChange = useCallback(
-    (newlayout) => {
-      const newLayoutClone = cloneLayout(newlayout);
-      refState.current.layouts[refState.current.currentBreakpoint] = newLayoutClone;
-      setCurrentState((prev) => ({ ...prev, breakpointLayout: newLayoutClone }));
-    },
-    [onLayoutChange]
-  );
-  return /* @__PURE__ */ jsx(
-    GridLayout,
-    {
-      rowHeight: currentState.rowHeight,
-      containerWidth,
-      containerHeight,
-      colapsedHeight: currentState.colapsedHeight,
-      layoutItemRender,
-      margin: currentState.contaierMargin,
-      containerPadding: getIndentationValue(containerPadding, currentState.breakpoint),
-      onLayoutChange: localOnLayoutChange,
-      layout: currentState.breakpointLayout,
-      cols: currentState.cols,
-      compactType,
-      ...other
-    }
-  );
-}
-export {
-  Responsive as R,
-  addLayoutItemToBreakPointIfNoExists as a,
-  addLayoutItemToBreakPoints as b,
-  cloneLayouts as c
-};

package/components/GridLayout/subcomponents/SizeProvider/index-1aJ-e_54.js

@@ -1,71 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { useRef, useState, useMemo, useCallback, useEffect } from "react";
-import clsx from "clsx";
-import { throttle } from "lodash";
-import { useResizeObserver } from "@m4l/graphics";
-import { j as DEFAULT_CONTAINER_WIDTH, k as DEFAULT_CONTAINER_HEIGHT, T as THROTTLE_RESIZE_TIMEOUT, C as COMPONENT_CLASS_NAME } from "../../index-C4HyxNYX.js";
-function withSizeProvider(ComposedComponent) {
-  return (props) => {
-    const { measureBeforeMount = true, ...rest } = props;
-    const refMounted = useRef(false);
-    const [currentState, setCurrentState] = useState({
-      mounted: false,
-      width: DEFAULT_CONTAINER_WIDTH,
-      height: DEFAULT_CONTAINER_HEIGHT
-    });
-    const onWindowResizeMemo = useMemo(
-      () => () => {
-        const node = elementRef.current;
-        if (node instanceof HTMLElement && node.clientWidth) {
-          setCurrentState((prev) => ({
-            ...prev,
-            width: node.clientWidth,
-            //
-            height: node.offsetHeight
-          }));
-        }
-      },
-      []
-    );
-    const throttleResize = throttle(onWindowResizeMemo, THROTTLE_RESIZE_TIMEOUT, {
-      leading: false,
-      // No enviar el primer evento de resizing
-      trailing: true
-      // Incluir siempre el ultimo evento en la cola, para que no quede se quedee a la mitad de resizing
-    });
-    const onResize = useCallback((_target) => {
-      throttleResize();
-    }, []);
-    const elementRef = useResizeObserver(onResize);
-    useEffect(() => {
-      setCurrentState((prev) => ({ ...prev, mounted: true }));
-      refMounted.current = true;
-      onWindowResizeMemo();
-    }, []);
-    if (measureBeforeMount && !currentState.mounted) {
-      return /* @__PURE__ */ jsx(
-        "div",
-        {
-          className: clsx(props.className, COMPONENT_CLASS_NAME),
-          style: props.style,
-          ref: elementRef
-        }
-      );
-    }
-    return (
-      //@ts-expect-error
-      /* @__PURE__ */ jsx(
-        ComposedComponent,
-        {
-          innerRef: elementRef,
-          containerWidth: currentState.width,
-          containerHeight: currentState.height,
-          ...rest
-        }
-      )
-    );
-  };
-}
-export {
-  withSizeProvider as w
-};

package/components/HelperText/index-Crn_XIPF.js

@@ -1,50 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { H as HelperTextRoot } from "../../styles/index-DKj6m8SL.js";
-import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
-import { unstable_composeClasses } from "@mui/base";
-import { T as Typography } from "../mui_extended/Typography/index-Cf_4Zw8f.js";
-const componentName = "M4LHelperText";
-const errorLabelClasses = generateUtilityClasses(componentName, [
-  /* elements */
-  "root",
-  /* states or variants of elements */
-  "variantInfo",
-  "variantSuccess",
-  "variantWarning",
-  "variantError"
-]);
-function getHelperTextUtilityClass(slot) {
-  return generateUtilityClass(componentName, slot);
-}
-const useUtilityClasses = (ownerSate) => {
-  const slots = {
-    root: [
-      "root",
-      ownerSate.variant === "info" && "variantInfo",
-      ownerSate.variant === "success" && "variantSuccess",
-      ownerSate.variant === "warning" && "variantWarning",
-      ownerSate.variant === "error" && "variantError"
-    ]
-  };
-  const composedClasses = unstable_composeClasses(slots, getHelperTextUtilityClass, {});
-  return {
-    ...composedClasses
-  };
-};
-const HelperText = (props) => {
-  const { message = "", skeletonWidth, skeletongHeight, variant } = props;
-  const ownerSate = {
-    variant
-  };
-  const classes = useUtilityClasses(ownerSate);
-  return (
-    /* ErrorLabelRoot: Contenedor principal del componente, es usado para aplicar los estilos css de los overrides
-        que provienen del objeto del tema. Se usa para garantizar de que estos estilos no se propaguen a otros
-        componentes de la plataforna web. */
-    /* @__PURE__ */ jsx(HelperTextRoot, { className: classes.root, children: /* @__PURE__ */ jsx(Typography, { variant: "body", skeletonWidth, skeletongHeight, children: message }) })
-  );
-};
-export {
-  HelperText as H,
-  errorLabelClasses as e
-};

package/components/Icon/index-C89MAkeH.js

@@ -1,176 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { Marker } from "react-leaflet";
-import L__default from "leaflet";
-import { m as mapClasses, L as LABEL_BK_COLOR_DEFAULT, a as LABEL_COLOR_DEFAULT } from "../maps/components/Map/index-2Lx5ARXa.js";
-import clsx from "clsx";
-import { useEnvironment } from "@m4l/core";
-import { I as IconRoot, e as DivIcon, f as ArrowIconRoot } from "../../styles/index-DKj6m8SL.js";
-import { u as useSideBar, g as getNameDataTestId$1 } from "../SideBar/index-PUBBe0yH.js";
-import { T as TEST_PROP_ID } from "../../test/constants_no_mock-CF-669v-.js";
-import { generateUtilityClasses, generateUtilityClass } from "@mui/material";
-import { unstable_composeClasses } from "@mui/base";
-import { useResponsiveDesktop } from "@m4l/graphics";
-const componentName = "M4LIcon";
-generateUtilityClasses(componentName, [
-  /* elements */
-  "root",
-  "icon",
-  "variantSkeleton",
-  /* states or variants of elements */
-  "sizeExtraSmall",
-  "sizeSmall",
-  "sizeMedium",
-  "sizeLarge",
-  "sizeExtraLarge",
-  "rotationAngle"
-]);
-function getIconClassesUtilityClass(slot) {
-  return generateUtilityClass(componentName, slot);
-}
-const useUtilityClasses = (ownerState) => {
-  const slots = {
-    root: ["root"],
-    icon: [
-      "icon",
-      ownerState.size === "extraSmall" && "sizeExtraSmall",
-      ownerState.size === "small" && "sizeSmall",
-      ownerState.size === "medium" && "sizeMedium",
-      ownerState.size === "large" && "sizeLarge",
-      ownerState.size === "extraLarge" && "sizeExtraLarge",
-      ownerState.rotationAngle ? "rotationAngle" : ""
-    ],
-    variantSkeleton: [
-      "variantSkeleton",
-      ownerState.size === "extraSmall" && "sizeExtraSmall",
-      ownerState.size === "small" && "sizeSmall",
-      ownerState.size === "medium" && "sizeMedium",
-      ownerState.size === "large" && "sizeLarge",
-      ownerState.size === "extraLarge" && "sizeExtraLarge"
-    ]
-  };
-  const composedClasses = unstable_composeClasses(slots, getIconClassesUtilityClass, {});
-  return {
-    ...composedClasses
-  };
-};
-const ICON_PREFIX = "Icon";
-const getNameDataTestId = (KEY) => {
-  return `${ICON_PREFIX}-${KEY}`;
-};
-function Icon(props) {
-  const { src, size = "small", rotationAngle, className } = props;
-  const isDesktop = useResponsiveDesktop();
-  const ownerState = {
-    size: isDesktop ? size : "medium",
-    rotationAngle
-  };
-  const classes = useUtilityClasses(ownerState);
-  return /* @__PURE__ */ jsx(
-    IconRoot,
-    {
-      className: clsx(classes.root, className),
-      ...process.env.NODE_ENV !== "production" ? { [TEST_PROP_ID]: getNameDataTestId("root") } : {},
-      children: /* @__PURE__ */ jsx(
-        DivIcon,
-        {
-          className: classes.icon,
-          src,
-          rotationAngle,
-          ...process.env.NODE_ENV !== "production" ? { [TEST_PROP_ID]: getNameDataTestId("icon") } : {}
-        }
-      )
-    }
-  );
-}
-const FeatureDivIconLabel = (props) => {
-  const {
-    label,
-    iconSrc,
-    iconScale: scale = 1,
-    iconRotate,
-    labelBkColor: bkColor = LABEL_BK_COLOR_DEFAULT,
-    labelColor: color = LABEL_COLOR_DEFAULT,
-    iconWidth = 24,
-    iconHeight = 24,
-    offsetLeftTop = [24, 0]
-  } = props;
-  let html = label ? `<div class="${mapClasses.featureLabel}" 
-                style="background-color:${bkColor}; color:${color};left:${offsetLeftTop[0]}px;top:${offsetLeftTop[1]}px;">${label}</div>` : "";
-  if (iconSrc) {
-    html = `<div class="${mapClasses.markerLayerIcon}" style="transform: rotate(${iconRotate}deg) scale(${scale}); transform-origin: center center;">
-                    <img src=${iconSrc}></img>
-                </div>` + html;
-  }
-  return L__default.divIcon({
-    className: clsx(mapClasses.markerLayerRoot, ""),
-    iconSize: [iconWidth, iconHeight],
-    // iconAnchor: [-width, height/2],
-    html
-  });
-};
-const MarkerIconLabel = (props) => {
-  const {
-    position,
-    draggable = true,
-    iconSrc,
-    iconRotate,
-    iconScale: scale,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    className,
-    label,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    markerColor,
-    labelBkColor: bkColor,
-    labelColor: color,
-    iconWidth,
-    iconHeight,
-    offsetLeftTop,
-    ...properties
-  } = props;
-  const makerIcon = FeatureDivIconLabel({
-    iconSrc,
-    iconRotate,
-    iconScale: scale,
-    label,
-    iconWidth,
-    iconHeight,
-    labelBkColor: bkColor,
-    labelColor: color,
-    offsetLeftTop
-  });
-  return /* @__PURE__ */ jsx(
-    Marker,
-    {
-      position,
-      draggable,
-      riseOnHover: true,
-      icon: makerIcon,
-      ...properties
-    },
-    Math.random()
-  );
-};
-function ArrowIcon(props) {
-  const { openState } = props;
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const { classes } = useSideBar();
-  return /* @__PURE__ */ jsx(
-    ArrowIconRoot,
-    {
-      className: classes.arrowIconRoot,
-      ...process.env.NODE_ENV !== "production" ? { [TEST_PROP_ID]: getNameDataTestId$1("arrowIconRoot") } : {},
-      children: /* @__PURE__ */ jsx(
-        Icon,
-        {
-          src: `${host_static_assets}/${environment_assets}/frontend/components/sidebar/assets/icons/ChevronRight.svg`,
-          rotationAngle: openState ? 90 : 0
-        }
-      )
-    }
-  );
-}
-export {
-  ArrowIcon as A,
-  Icon as I,
-  MarkerIconLabel as M
-};