@m4l/components 1.0.21 → 1.0.22

package/components/DragResizeWindow/index.4fea43a8.js

@@ -1,480 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { forwardRef, useState, useRef, useImperativeHandle, useCallback, useEffect, useMemo } from "react";
-import { D as DraggableCore_1 } from "../../react-draggable.1c1ba224.js";
-import clsx from "clsx";
-import { styled, generateUtilityClasses } from "@mui/material";
-import { M as MAP_ZINDEX_OVER_MAP } from "../maps/components/Map/index.9edada74.js";
-import "@mui/base";
-import { M as MAP_ZINDEX_OVER_MAP$1 } from "../popups/PopupsViewer/index.f36f3bcc.js";
-import { R as Resizable } from "../../react-resizable.a59c14f4.js";
-const WrapperWindowRoot = styled("div")`
-  position: absolute;
-  left: 0px;
-  top: 0px;
-  background-color: gray;
-  z-index: ${MAP_ZINDEX_OVER_MAP};
-  prop2: 2;
-
-  ${(props) => props.theme.components?.M4LDragResizeWindow?.styleOverrides}
-`;
-const COMPONENT_CLASS_NAME = "M4LDraggableWindow";
-const DEFAULT_TRANSFORM_SCALE = 1;
-const draggableWindowClasses = generateUtilityClasses(
-  COMPONENT_CLASS_NAME,
-  [
-    "root",
-    "draggableHandle",
-    "draggableCancel",
-    "dragging"
-  ]
-);
-function setTransform({ top, left, width, height }) {
-  const translate = `translate(${left}px,${top}px)`;
-  return {
-    transform: translate,
-    WebkitTransform: translate,
-    MozTransform: translate,
-    msTransform: translate,
-    OTransform: translate,
-    width: `${width}px`,
-    height: `${height}px`,
-    position: "absolute",
-    prop1: 1
-  };
-}
-const DragResizeWindow = forwardRef(
-  function DragResizeWindowForwardRef(props, ref) {
-    const {
-      style,
-      className,
-      children,
-      defaultPosition = { vertical: { top: 0, height: 100 }, horizontal: { left: 0, width: 100 } },
-      containerElement,
-      containerSize,
-      transformScale = DEFAULT_TRANSFORM_SCALE,
-      bounds = { left: 5, top: 5, right: -5, bottom: -5 },
-      minWindowWidth = 200,
-      minWindowHeight = 100,
-      draggableHandle = `.${draggableWindowClasses.draggableHandle}`,
-      draggableCancel = `.${draggableWindowClasses.draggableCancel}`,
-      draggable = true,
-      onDragStart,
-      onDrag,
-      onDragStop,
-      onMouseDown,
-      resizeable = true,
-      resizeHandles = ["se", "nw"],
-      resizeHandle,
-      onResizeStart,
-      onResize,
-      onResizeStop,
-      ...others
-    } = props;
-    const [currentState, setCurrentState] = useState(() => {
-      let top;
-      let bottom;
-      let height;
-      let left;
-      let right;
-      let width;
-      if ("top" in defaultPosition.vertical) {
-        top = defaultPosition.vertical.top;
-      }
-      if ("bottom" in defaultPosition.vertical) {
-        bottom = defaultPosition.vertical.bottom;
-      }
-      if ("height" in defaultPosition.vertical) {
-        height = defaultPosition.vertical.height;
-      }
-      if ("left" in defaultPosition.horizontal) {
-        left = defaultPosition.horizontal.left;
-      }
-      if ("right" in defaultPosition.horizontal) {
-        right = defaultPosition.horizontal.right;
-      }
-      if ("width" in defaultPosition.horizontal) {
-        width = defaultPosition.horizontal.width;
-      }
-      const containerHeight = containerSize?.containerHeight || 200;
-      const containerWidth = containerSize?.containerWidth || 200;
-      return {
-        top: top || 0,
-        height: height ?? containerHeight - (top || 0) - (bottom || 0),
-        left: left ?? (right ? containerWidth - right - (width || 0) : 0),
-        width: width ?? containerWidth - (left || 0) - (right || 0)
-      };
-    });
-    const stateRef = useRef({
-      bounds,
-      data: void 0,
-      dragging: void 0,
-      containerSize: containerSize ? { ...containerSize } : void 0,
-      left: currentState.left,
-      top: currentState.top,
-      width: currentState.width,
-      height: currentState.height
-    });
-    useImperativeHandle(ref, () => {
-      return {
-        current: wrapperRef.current
-      };
-    });
-    const wrapperRef = useRef(null);
-    const localOnDragStart = useCallback((e, draggableData) => {
-      const { node } = draggableData;
-      const newPosition = { top: 0, left: 0 };
-      const parentRect = containerElement.getBoundingClientRect();
-      const clientRect = node.getBoundingClientRect();
-      const cLeft = clientRect.left / transformScale;
-      const pLeft = parentRect.left / transformScale;
-      const cTop = clientRect.top / transformScale;
-      const pTop = parentRect.top / transformScale;
-      newPosition.left = cLeft - pLeft + containerElement.scrollLeft;
-      newPosition.top = cTop - pTop + containerElement.scrollTop;
-      if (onDragStart) {
-        if (onDragStart(e, draggableData) === false) {
-          return false;
-        }
-      }
-      stateRef.current.dragging = newPosition;
-      setCurrentState((prev) => ({
-        ...prev,
-        ...newPosition,
-        shrinkLeftAt: void 0,
-        shrinkTopAt: void 0,
-        overflowWidthAt: void 0,
-        overflowHeightAt: void 0,
-        dragging: newPosition
-      }));
-    }, []);
-    const localOnDrag = useCallback((e, draggableData) => {
-      const { deltaX, deltaY } = draggableData;
-      if (!stateRef.current.dragging) {
-        return;
-      }
-      if (onDrag) {
-        if (onDrag(e, draggableData) === false) {
-          return false;
-        }
-      }
-      const top = stateRef.current.dragging.top + deltaY;
-      const left = stateRef.current.dragging.left + deltaX;
-      const newPosition = { top, left };
-      stateRef.current.dragging = newPosition;
-      setCurrentState((prev) => ({ ...prev, ...newPosition, dragging: newPosition }));
-    }, []);
-    const localOnDragStop = useCallback((e, draggableData) => {
-      if (!stateRef.current.dragging) {
-        return;
-      }
-      const { left, top } = stateRef.current.dragging;
-      if (onDragStop) {
-        if (onDragStop(e, draggableData) === false) {
-          return false;
-        }
-      }
-      const newPosition = { top, left };
-      stateRef.current.dragging = void 0;
-      setCurrentState((prev) => ({ ...prev, ...newPosition, dragging: void 0 }));
-    }, []);
-    const onResizeHandler = useCallback(
-      (e, data, handlerName) => {
-        const { size, handle } = data;
-        const handler = props[handlerName];
-        containerElement.getBoundingClientRect();
-        if (handler) {
-          handler(e, data);
-        }
-        if (handlerName === "onResizeStart") {
-          stateRef.current.initialPostion = {
-            left: stateRef.current.left,
-            top: stateRef.current.top,
-            width: stateRef.current.width,
-            height: stateRef.current.height
-          };
-        }
-        const resizing = handlerName === "onResizeStop" ? void 0 : { ...size, handle };
-        setCurrentState((prev) => ({
-          ...prev,
-          ...size,
-          ...handlerName === "onResizeStart" ? {
-            shrinkLeftAt: void 0,
-            shrinkTopAt: void 0,
-            overflowWidthAt: void 0,
-            overflowHeightAt: void 0
-          } : {},
-          resizing
-        }));
-        stateRef.current.resizing = resizing;
-      },
-      []
-    );
-    const localOnResizeStart = useCallback(
-      (e, callbackData) => {
-        onResizeHandler(e, callbackData, "onResizeStart");
-      },
-      []
-    );
-    const localOnResize = useCallback((e, callbackData) => {
-      onResizeHandler(e, callbackData, "onResize");
-    }, []);
-    const localOnResizeStop = useCallback((e, callbackData) => {
-      onResizeHandler(e, callbackData, "onResizeStop");
-    }, []);
-    const shringkingParentContainer = useCallback(
-      (newState, cState, containerDimension, divRoot, dimension) => {
-        const lDimension = dimension === "Width" ? "width" : "height";
-        const leftTop = dimension === "Width" ? "left" : "top";
-        const shrinkLeftTopAt = dimension === "Width" ? "shrinkLeftAt" : "shrinkTopAt";
-        const overflowDimensionAt = dimension === "Width" ? "overflowWidthAt" : "overflowHeightAt";
-        const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
-        const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
-        const minWindowDimension = dimension === "Width" ? minWindowWidth : minWindowHeight;
-        const minDimension = containerDimension - boundsLefTop + boundsRigthBottom > minWindowDimension ? containerDimension - boundsLefTop + boundsRigthBottom : minWindowDimension;
-        let maxDimensionElement = containerDimension - cState[leftTop] + boundsRigthBottom;
-        if (divRoot[`client${dimension}`] > maxDimensionElement) {
-          const shrinkedPixels = divRoot[`client${dimension}`] - maxDimensionElement;
-          if (shrinkedPixels < cState[leftTop] - boundsLefTop) {
-            newState[leftTop] = newState[leftTop] - shrinkedPixels;
-            newState[shrinkLeftTopAt] = newState[shrinkLeftTopAt] || cState[leftTop];
-          } else if (shrinkedPixels > cState[leftTop] - boundsLefTop) {
-            newState[leftTop] = boundsLefTop;
-            newState[shrinkLeftTopAt] = newState[shrinkLeftTopAt] || cState[leftTop];
-            maxDimensionElement = containerDimension - boundsLefTop + boundsRigthBottom;
-            if (divRoot[`client${dimension}`] > maxDimensionElement) {
-              newState[lDimension] = maxDimensionElement;
-              newState[overflowDimensionAt] = newState[overflowDimensionAt] || cState[lDimension];
-              if (newState[lDimension] < minDimension) {
-                newState[lDimension] = minDimension;
-              }
-            }
-          }
-        } else {
-          return;
-        }
-      },
-      []
-    );
-    const expandingParentContainer = useCallback(
-      (newState, _currentState, containerDimension, _divRoot, dimension) => {
-        const lDimension = dimension === "Width" ? "width" : "height";
-        const leftTop = dimension === "Width" ? "left" : "top";
-        const shrinkLeftTopAt = dimension === "Width" ? "shrinkLeftAt" : "shrinkTopAt";
-        const overflowDimensionAt = dimension === "Width" ? "overflowWidthAt" : "overflowHeightAt";
-        const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
-        const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
-        const maxDimensionElement = containerDimension - boundsLefTop + boundsRigthBottom;
-        const valOverflowDimensionAt = newState[overflowDimensionAt];
-        if (valOverflowDimensionAt) {
-          if (valOverflowDimensionAt > maxDimensionElement) {
-            newState[lDimension] = maxDimensionElement;
-          } else {
-            newState[lDimension] = valOverflowDimensionAt;
-            newState[overflowDimensionAt] = void 0;
-          }
-        }
-        const valShrinkLeftTopAt = newState[shrinkLeftTopAt];
-        if (valShrinkLeftTopAt && !newState[overflowDimensionAt]) {
-          const dimensionAvailable = containerDimension - boundsLefTop - newState[lDimension] + boundsRigthBottom;
-          if (valShrinkLeftTopAt <= dimensionAvailable) {
-            newState[leftTop] = valShrinkLeftTopAt;
-            newState[shrinkLeftTopAt] = void 0;
-          } else {
-            newState[leftTop] = dimensionAvailable;
-          }
-        }
-      },
-      []
-    );
-    const draggingOrResizingWindow = useCallback(
-      (newState, _currentState, containerDimension, divRoot, dimension) => {
-        const lDimension = dimension === "Width" ? "width" : "height";
-        const leftTop = dimension === "Width" ? "left" : "top";
-        const boundsLefTop = dimension === "Width" ? bounds?.left || 0 : bounds?.top || 0;
-        const boundsRigthBottom = dimension === "Width" ? bounds?.right || 0 : bounds?.bottom || 0;
-        const maxDimensionWithoutBounds = containerDimension - boundsLefTop + boundsRigthBottom;
-        let rightBottomBoundary = containerDimension - newState[lDimension] + boundsRigthBottom;
-        if (newState[lDimension] !== divRoot[`client${dimension}`])
-          ;
-        if (newState.resizing && stateRef.current.initialPostion) {
-          if (!newState.resizing.handle.includes("w")) {
-            if (newState[leftTop] + newState[lDimension] > containerDimension + boundsRigthBottom) {
-              newState[lDimension] = containerDimension - newState[leftTop] + boundsRigthBottom;
-            }
-          } else {
-            if (newState[leftTop] < boundsLefTop) {
-              newState[leftTop] = boundsLefTop;
-            } else {
-              const dif = newState[lDimension] - stateRef.current.initialPostion[lDimension];
-              if (dif > 0) {
-                if (newState[leftTop] - dif >= boundsLefTop) {
-                  newState[lDimension] = stateRef.current.initialPostion[lDimension] + dif;
-                  newState[leftTop] = newState[leftTop] - dif;
-                  if (newState[leftTop] + newState[lDimension] > maxDimensionWithoutBounds)
-                    ;
-                } else {
-                  newState[leftTop] = boundsLefTop;
-                  newState[lDimension] = stateRef.current.initialPostion[lDimension];
-                }
-              } else if (dif < 0) {
-                newState[leftTop] = newState[leftTop] - dif;
-                newState[lDimension] = stateRef.current.initialPostion[lDimension] + dif;
-              }
-            }
-          }
-        }
-        if (newState[lDimension] > maxDimensionWithoutBounds) {
-          newState[lDimension] = maxDimensionWithoutBounds;
-        }
-        if (newState[leftTop] < boundsLefTop) {
-          newState[leftTop] = boundsLefTop;
-        }
-        rightBottomBoundary = containerDimension + boundsRigthBottom;
-        if (newState[leftTop] > rightBottomBoundary) {
-          newState[leftTop] = rightBottomBoundary;
-        }
-        if (!newState.resizing && newState[leftTop] + newState[lDimension] > containerDimension + boundsRigthBottom) {
-          const outWidthHeight = newState[leftTop] + newState[lDimension] - (containerDimension + boundsRigthBottom);
-          if (newState[leftTop] - boundsLefTop > outWidthHeight) {
-            newState[leftTop] = newState[leftTop] - outWidthHeight;
-          }
-        }
-        if (newState.resizing && stateRef.current.initialPostion) {
-          stateRef.current.initialPostion[lDimension] = newState[lDimension];
-          stateRef.current.initialPostion[leftTop] = newState[leftTop];
-        }
-      },
-      []
-    );
-    useEffect(() => {
-      if (stateRef.current.containerSize === void 0 && containerSize) {
-        stateRef.current.containerSize = containerSize;
-      }
-      if (!(containerSize && wrapperRef?.current && stateRef.current.containerSize)) {
-        return;
-      }
-      if (currentState?.dragging) {
-        return;
-      }
-      const newState = { ...currentState };
-      const handleDimension = (dimension) => {
-        if (stateRef.current?.containerSize && wrapperRef.current) {
-          const containerSizeKey = `container${dimension}`;
-          const containerSizeValue = containerSize[containerSizeKey];
-          const previousContainerSizeValue = stateRef.current.containerSize[containerSizeKey];
-          if (containerSizeValue > previousContainerSizeValue) {
-            expandingParentContainer(
-              newState,
-              currentState,
-              containerSizeValue,
-              wrapperRef.current,
-              dimension
-            );
-          } else if (containerSizeValue < previousContainerSizeValue) {
-            shringkingParentContainer(
-              newState,
-              currentState,
-              containerSizeValue,
-              wrapperRef.current,
-              dimension
-            );
-          } else {
-            draggingOrResizingWindow(
-              newState,
-              currentState,
-              containerSizeValue,
-              wrapperRef.current,
-              dimension
-            );
-          }
-        }
-      };
-      handleDimension("Width");
-      handleDimension("Height");
-      stateRef.current.containerSize = { ...containerSize };
-      if (newState.left !== currentState.left || newState.top !== currentState.top || newState.width !== currentState.width || newState.height !== currentState.height || newState.shrinkLeftAt !== currentState.shrinkLeftAt || newState.shrinkTopAt !== currentState.shrinkTopAt || newState.overflowWidthAt !== currentState.overflowWidthAt || newState.overflowHeightAt !== currentState.overflowHeightAt) {
-        setCurrentState(newState);
-      }
-      if (!newState.resizing) {
-        stateRef.current.left = newState.left;
-        stateRef.current.top = newState.top;
-        stateRef.current.height = newState.height;
-        stateRef.current.width = newState.width;
-      }
-    }, [
-      currentState,
-      wrapperRef.current,
-      bounds?.left,
-      bounds?.top,
-      bounds?.right,
-      bounds?.bottom,
-      containerSize?.containerWidth,
-      containerSize?.containerHeight
-    ]);
-    const mixinResizable = useCallback(
-      (child, position) => {
-        const minConstraints = [minWindowWidth, minWindowHeight];
-        return /* @__PURE__ */ jsx(
-          Resizable,
-          {
-            draggableOpts: {
-              disabled: !resizeable
-            },
-            className: resizeable ? void 0 : "react-resizable-hide",
-            width: position.width,
-            height: position.height,
-            minConstraints,
-            onResizeStop: localOnResizeStop,
-            onResizeStart: localOnResizeStart,
-            onResize: localOnResize,
-            transformScale,
-            resizeHandles,
-            handle: resizeHandle,
-            children: child
-          }
-        );
-      },
-      [resizeable, transformScale]
-    );
-    const mixinDraggable = useCallback(
-      (child) => {
-        return /* @__PURE__ */ jsx(
-          DraggableCore_1,
-          {
-            onStart: localOnDragStart,
-            onDrag: localOnDrag,
-            onStop: localOnDragStop,
-            handle: draggableHandle,
-            cancel: ".react-resizable-handle" + (draggableCancel ? "," + draggableCancel : ""),
-            scale: transformScale,
-            nodeRef: wrapperRef,
-            onMouseDown,
-            ...others,
-            children: child
-          }
-        );
-      },
-      [wrapperRef, transformScale, draggableHandle, draggableCancel]
-    );
-    const classNameFinal = clsx(draggableWindowClasses.root, className, {
-      "react-draggable": true
-    });
-    const styleFinal = {
-      ...style,
-      ...setTransform(currentState),
-      zIndex: MAP_ZINDEX_OVER_MAP$1,
-      prop2: 1,
-      backgroundColor: "gray"
-    };
-    const memoChildren = useMemo(() => {
-      return children;
-    }, [children]);
-    const wrapperRoot = /* @__PURE__ */ jsx(WrapperWindowRoot, { className: classNameFinal, ref: wrapperRef, style: styleFinal, role: "none", children: memoChildren });
-    const dragResizeWindow = mixinDraggable(mixinResizable(wrapperRoot, currentState));
-    return dragResizeWindow;
-  }
-);
-export {
-  DragResizeWindow as D,
-  draggableWindowClasses as d
-};

package/components/maps/components/GpsTools/GpsTools.d.ts

@@ -1 +0,0 @@
-export declare function GpsTools(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsTools/icons.d.ts

@@ -1,15 +0,0 @@
-export declare const GPSTOOLSICONS: {
-    GEOMETRY_CIRCLE: string;
-    GEOMETRY_RECTANGLE: string;
-    GEOMETRY_POLYGON: string;
-    ADD: string;
-    MEASURE: string;
-    GENERAL: string;
-    CONFIG: string;
-    STROKE: string;
-    FILL: string;
-    EDIT: string;
-    DELETE: string;
-    ACTIVE: string;
-    NAME: string;
-};