@m4l/components 9.2.12 → 9.2.15-beta.2

package/components/DragResizeWindow/hooks/useDimensionEffects.d.ts

@@ -1,23 +0,0 @@
-import { default as React } from 'react';
-import { CurrentState, StateRef, DraggableWindowBounds } from '../types';
-import { ContainerSize } from '../../../utils/types';
-type useOnDragStartProps = {
-    containerElement?: HTMLElement | null;
-    containerSize: ContainerSize | undefined;
-    bounds?: DraggableWindowBounds;
-    minWindowWidth: number;
-    minWindowHeight: number;
-    stateRef: React.MutableRefObject<StateRef>;
-    wrapperRef: React.RefObject<HTMLDivElement>;
-    currentState: CurrentState;
-    setCurrentState: React.Dispatch<React.SetStateAction<CurrentState>>;
-    allowHeightResizeContainer?: boolean;
-    allowWidthResizeContainer?: boolean;
-};
-/**
- * "useDimensionEffects" Redimensiona la ventana si el contenedor padre es desbordado por ella.
- * Guarda las posiciones de la ventana cuando se encoge el contenedor padre, para recuperarlas cuando se expanda.
- * @param props
- */
-export declare const useDimensionEffects: (props: useOnDragStartProps) => void;
-export {};

package/components/DragResizeWindow/hooks/useDimensionEffects.js

@@ -1,92 +0,0 @@
-import { useEffect } from "react";
-import { e as expandingParentContainer } from "../helpers/expandingParentContainer.js";
-import { s as shrinkingParentContainer } from "../helpers/shrinkingParentContainer.js";
-const useDimensionEffects = (props) => {
-  const {
-    containerElement,
-    containerSize,
-    bounds,
-    minWindowWidth,
-    minWindowHeight,
-    stateRef,
-    wrapperRef,
-    currentState,
-    setCurrentState,
-    allowHeightResizeContainer,
-    allowWidthResizeContainer
-  } = props;
-  useEffect(() => {
-    if (!containerElement) {
-      return;
-    }
-    if (containerSize?.containerHeight === 0 && containerSize?.containerWidth === 0) {
-      return;
-    }
-    if (stateRef.current.containerSize === void 0 && containerSize) {
-      stateRef.current.containerSize = containerSize;
-    }
-    if (!(containerSize && wrapperRef?.current && stateRef.current.containerSize)) {
-      return;
-    }
-    if (currentState?.dragging) {
-      return;
-    }
-    if (currentState?.resizing) {
-      return;
-    }
-    const newState = { ...currentState };
-    const handleDimension = (dimension, allowResizeContainer = false) => {
-      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) {
-          shrinkingParentContainer(
-            newState,
-            currentState,
-            containerSizeValue,
-            wrapperRef.current,
-            dimension,
-            allowResizeContainer,
-            minWindowWidth,
-            minWindowHeight,
-            bounds
-          );
-        }
-      }
-    };
-    handleDimension("Width", allowWidthResizeContainer);
-    handleDimension("Height", allowHeightResizeContainer);
-    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;
-    }
-  }, [
-    containerElement,
-    currentState,
-    wrapperRef.current,
-    bounds?.left,
-    bounds?.top,
-    bounds?.right,
-    bounds?.bottom,
-    containerSize?.containerWidth,
-    containerSize?.containerHeight
-  ]);
-};
-export {
-  useDimensionEffects as u
-};

package/components/DragResizeWindow/hooks/useDragOptions.d.ts

@@ -1,28 +0,0 @@
-import { default as React } from 'react';
-import { DraggableData, DraggableEvent } from 'react-draggable';
-import { CurrentState, StateRef } from '../types';
-type useDragOptionsProps = {
-    allowHeightResizeContainer?: boolean;
-    allowWidthResizeContainer?: boolean;
-    containerElement?: HTMLElement;
-    onDragStart?: (e: DraggableEvent, draggableData: DraggableData) => boolean | void;
-    onDrag?: (e: DraggableEvent, draggableData: DraggableData) => boolean | void;
-    onDragStop?: (e: DraggableEvent, draggableData: DraggableData) => boolean | void;
-    transformScale: number;
-    stateRef: React.MutableRefObject<StateRef>;
-    setCurrentState: React.Dispatch<React.SetStateAction<CurrentState>>;
-    autoScroll?: {
-        enabled?: boolean;
-        speed?: number;
-        threshold?: number;
-    };
-};
-/**
- * "useDragOptions" hook que maneja las opciones de dragging
- */
-export declare const useDragOptions: (props: useDragOptionsProps) => {
-    localOnDragStart: (e: DraggableEvent, draggableData: DraggableData) => false | undefined;
-    localOnDrag: (e: DraggableEvent, draggableData: DraggableData) => false | undefined;
-    localOnDragStop: (e: DraggableEvent, draggableData: DraggableData) => void;
-};
-export {};

package/components/DragResizeWindow/hooks/useDragOptions.js

@@ -1,167 +0,0 @@
-import { useRef, useCallback } from "react";
-import { g as getDetailedPointPosition } from "../helpers/pointPosition.js";
-const useDragOptions = (props) => {
-  const {
-    containerElement,
-    onDragStart,
-    onDrag,
-    onDragStop,
-    transformScale,
-    stateRef,
-    setCurrentState,
-    allowHeightResizeContainer,
-    allowWidthResizeContainer
-  } = props;
-  const dragPointRef = useRef({ x: 0, y: 0 });
-  const localOnDragStart = useCallback(
-    (e, draggableData) => {
-      const { node } = draggableData;
-      const newPosition = { top: 0, left: 0 };
-      if (!containerElement) {
-        return;
-      }
-      if (e.type === "mousedown" || e.type === "touchstart") {
-        const mouseEvent = e;
-        dragPointRef.current = {
-          x: mouseEvent.clientX,
-          y: mouseEvent.clientY
-        };
-      }
-      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,
-        //Cancelar los flags de memoria de encogimiento del contenedor padre
-        shrinkTopAt: void 0,
-        //Cancelar los flags de memoria de encogimiento del contenedor padre
-        overflowWidthAt: void 0,
-        //Cancelar los flags de memoria de encogimiento del contenedor padre
-        overflowHeightAt: void 0,
-        //Cancelar los flags de memoria de encogimiento del contenedor padre
-        dragging: newPosition
-      }));
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [containerElement, onDragStart, transformScale]
-  );
-  const localOnDrag = useCallback((e, draggableData) => {
-    const { deltaX, deltaY } = draggableData;
-    const finalDeltaY = deltaY;
-    const finalDeltaX = deltaX;
-    if (!stateRef.current.dragging) {
-      return;
-    }
-    if (!containerElement) {
-      return;
-    }
-    if (onDrag) {
-      if (onDrag(e, draggableData) === false) {
-        return false;
-      }
-    }
-    const [isInsideElementX, isInsideElementY] = getDetailedPointPosition(e, draggableData.node);
-    if (!isInsideElementX.isInside && isInsideElementX.isLeft && deltaX > 0) {
-      return;
-    }
-    if (!isInsideElementX.isInside && isInsideElementX.isRight && deltaX < 0) {
-      return;
-    }
-    if (!isInsideElementY.isInside && isInsideElementY.isAbove && deltaY > 0) {
-      return;
-    }
-    if (!isInsideElementY.isInside && isInsideElementY.isBelow && deltaY !== 0) {
-      return;
-    }
-    let left = stateRef.current.dragging.left + finalDeltaX;
-    let top = stateRef.current.dragging.top + finalDeltaY;
-    if (left < (stateRef.current.bounds?.left || 0)) {
-      left = stateRef.current.bounds?.left || 0;
-    }
-    if (!allowWidthResizeContainer) {
-      const totalWidth = containerElement.clientWidth;
-      if (left + stateRef.current.width > totalWidth + (stateRef.current.bounds?.right || 0)) {
-        left = totalWidth - stateRef.current.width + (stateRef.current.bounds?.right || 0);
-      }
-    }
-    if (top < (stateRef.current.bounds?.top || 0)) {
-      top = stateRef.current.bounds?.top || 0;
-    }
-    if (!allowHeightResizeContainer) {
-      const totalHeight = containerElement.clientHeight;
-      if (top + stateRef.current.height > totalHeight + (stateRef.current.bounds?.bottom || 0)) {
-        top = totalHeight - stateRef.current.height + (stateRef.current.bounds?.bottom || 0);
-      }
-    }
-    const elementHeight = stateRef.current.height;
-    const elementBottom = top + elementHeight;
-    const containerScrollTop = containerElement.scrollTop;
-    const containerHeight = containerElement.clientHeight;
-    const containerScrollLeft = containerElement.scrollLeft;
-    const containerVisibleTop = containerScrollTop;
-    const containerVisibleBottom = containerVisibleTop + containerHeight;
-    const containerVisibleLeft = containerElement.scrollLeft;
-    const containerVisibleRight = containerVisibleLeft + containerElement.clientWidth;
-    const scrollThreshold = 50;
-    if (deltaY < 0 && top < containerVisibleTop + scrollThreshold && containerScrollTop > 0) {
-      const scrollNeeded = Math.min(15, Math.min(scrollThreshold, containerScrollTop));
-      containerElement.scrollTop -= scrollNeeded;
-    }
-    if (deltaY > 0 && elementBottom > containerVisibleBottom - scrollThreshold) {
-      const scrollNeeded = Math.min(15, elementBottom - (containerVisibleBottom - scrollThreshold));
-      containerElement.scrollTop += scrollNeeded;
-    }
-    if (deltaX < 0 && left < containerVisibleLeft + scrollThreshold && containerScrollLeft > 0) {
-      const scrollNeeded = Math.min(15, Math.min(scrollThreshold, containerScrollLeft));
-      containerElement.scrollLeft -= scrollNeeded;
-    }
-    if (deltaX > 0 && left > containerVisibleRight - scrollThreshold) {
-      const scrollNeeded = Math.min(15, left - (containerVisibleRight - scrollThreshold));
-      containerElement.scrollLeft += scrollNeeded;
-    }
-    const newPosition = { top, left };
-    stateRef.current.dragging = newPosition;
-    setCurrentState((prev) => ({ ...prev, ...newPosition, dragging: newPosition }));
-  }, [allowHeightResizeContainer, allowWidthResizeContainer, containerElement, onDrag, setCurrentState, stateRef]);
-  const localOnDragStop = useCallback(
-    (e, draggableData) => {
-      if (!stateRef.current.dragging) {
-        return;
-      }
-      const { left, top } = stateRef.current.dragging;
-      stateRef.current = {
-        ...stateRef.current,
-        left,
-        top,
-        dragging: void 0
-      };
-      setCurrentState((prev) => ({
-        ...prev,
-        left,
-        top,
-        dragging: void 0
-      }));
-      if (onDragStop) {
-        onDragStop(e, draggableData);
-      }
-    },
-    [stateRef, setCurrentState, onDragStop]
-  );
-  return { localOnDragStart, localOnDrag, localOnDragStop };
-};
-export {
-  useDragOptions as u
-};

package/components/DragResizeWindow/hooks/useResizeOptions.d.ts

@@ -1,45 +0,0 @@
-import { default as React, SyntheticEvent } from 'react';
-import { CurrentState, StateRef, ResizeCallback } from '../types';
-import { ResizeCallbackData } from 'react-resizable';
-type useResizeOptionsProps = {
-    allowHeightResizeContainer?: boolean;
-    allowWidthResizeContainer?: boolean;
-    containerElement?: HTMLElement;
-    onResizeStart?: ResizeCallback;
-    onResize?: ResizeCallback;
-    onResizeStop?: ResizeCallback;
-    stateRef: React.MutableRefObject<StateRef>;
-    setCurrentState: React.Dispatch<React.SetStateAction<CurrentState>>;
-};
-/**
- * QUe solo se mueva si esta sobre el elemento de drag (Ok)
- * Cuadra el resize  que no esta funcionando bien con los bounds (Ok)
- * QUe solo haga resize si el mouse esta sobre el elemento
- * Que cuaando se este arrando o resize no gener eventos en los layouts (Ok)
- * Enfocar cuando es replaceMeId
- *
- */
-/**
- * `useResizeOptions` provides a set of handler functions for managing
- * resizing events (start, resize, and stop) on a component. This hook
- * centralizes the resize logic and coordinates state updates, including
- * calculating position changes and applying constraints.
- * @param props - The options required to configure the resize behavior,
- * including callbacks, references, and state setters.
- * @returns An object containing `localOnResize`, `localOnResizeStart`,
- * and `localOnResizeStop` handlers.
- * @example
- * const { localOnResize, localOnResizeStart, localOnResizeStop } = useResizeOptions({
- *   onResizeStart: handleResizeStart,
- *   onResize: handleResize,
- *   onResizeStop: handleResizeStop,
- *   stateRef,
- *   setCurrentState,
- * });
- */
-export declare const useResizeOptions: (props: useResizeOptionsProps) => {
-    localOnResize: (e: SyntheticEvent, callbackData: ResizeCallbackData) => void;
-    localOnResizeStart: (e: SyntheticEvent, callbackData: ResizeCallbackData) => void;
-    localOnResizeStop: (e: SyntheticEvent, callbackData: ResizeCallbackData) => void;
-};
-export {};

package/components/DragResizeWindow/hooks/useResizeOptions.js

@@ -1,218 +0,0 @@
-import { useEffect, useCallback } from "react";
-import { g as getDetailedPointPosition, i as isPointInDragStrip } from "../helpers/pointPosition.js";
-const useResizeOptions = (props) => {
-  const { onResizeStart: _onResizeStart, onResize: _onResize, stateRef, setCurrentState, containerElement, allowHeightResizeContainer, allowWidthResizeContainer } = props;
-  useEffect(() => {
-    if (!containerElement) {
-      return;
-    }
-    const handleScroll = (e) => {
-      const scrollTop = e.target.scrollTop;
-      const scrollLeft = e.target.scrollLeft;
-      if (stateRef.current.resizing) {
-        let change = false;
-        const lastScrollTop = stateRef.current.scrollTop || 0;
-        const lastScrollLeft = stateRef.current.scrollLeft || 0;
-        const newState = { top: stateRef.current.top, height: stateRef.current.height, left: stateRef.current.left, width: stateRef.current.width, scrollTop: lastScrollTop, scrollLeft: lastScrollLeft, resizeByScroll: stateRef.current.resizeByScroll };
-        const deltaTop = lastScrollTop - scrollTop;
-        const deltaLeft = lastScrollLeft - scrollLeft;
-        if (stateRef.current.resizing?.handle.includes("n")) {
-          if (deltaTop !== 0) {
-            if (newState.top - deltaTop > (stateRef.current.bounds?.top || 0)) {
-              newState.top = newState.top - deltaTop;
-              newState.height = newState.height + deltaTop;
-              newState.scrollTop = scrollTop;
-              newState.resizeByScroll = true;
-              change = true;
-            }
-          }
-        }
-        if (stateRef.current.resizing?.handle.includes("w")) {
-          if (newState.left - deltaLeft > (stateRef.current.bounds?.left || 0)) {
-            newState.left = newState.left - deltaLeft;
-            newState.width = newState.width + deltaLeft;
-            newState.scrollLeft = scrollLeft;
-            newState.resizeByScroll = true;
-            change = true;
-          }
-        }
-        if (change) {
-          setCurrentState({
-            ...newState
-          });
-          stateRef.current = {
-            ...stateRef.current,
-            ...newState
-          };
-        }
-      }
-    };
-    containerElement.addEventListener("scroll", handleScroll);
-    return () => {
-      containerElement?.removeEventListener("scroll", handleScroll);
-    };
-  }, [containerElement, setCurrentState, stateRef]);
-  const onResizeHandler = useCallback(
-    (e, data, handlerName) => {
-      const { size, handle, node: nodeElement } = data;
-      const handler = props[handlerName];
-      if (handler) {
-        handler(e, data);
-      }
-      e.stopPropagation();
-      if (!containerElement) {
-        return;
-      }
-      const [xContainerPosition, yContainerPosition] = getDetailedPointPosition(e, containerElement, stateRef.current.bounds);
-      const [xNodePosition, yNodePosition] = isPointInDragStrip(e, nodeElement);
-      const { containerSize = { containerWidth: 0, containerHeight: 0 } } = stateRef.current;
-      if (handlerName === "onResizeStart") {
-        stateRef.current.resizing = {
-          ...size,
-          handle,
-          startClientX: e.clientX,
-          startClientY: e.clientY,
-          startHeight: size.height,
-          startWidth: size.width
-        };
-      }
-      const newState = { left: stateRef.current.left, width: stateRef.current.width, top: stateRef.current.top, height: stateRef.current.height, resizeByScroll: stateRef.current.resizeByScroll };
-      const widthDelta = size.width - stateRef.current.width;
-      const heightDelta = size.height - stateRef.current.height;
-      if (handle.includes("w")) {
-        stateRef.current.scrollLeft = containerElement.scrollLeft;
-        const deltaLeft = stateRef.current.left - widthDelta;
-        if (xContainerPosition.isInside) {
-          if (deltaLeft > (stateRef.current.bounds?.left || 0)) {
-            newState.left = deltaLeft;
-            newState.width = size.width;
-          } else {
-            newState.left = stateRef.current.bounds?.left || 0;
-          }
-        } else {
-          if (xNodePosition.isInStrip) {
-            if (deltaLeft > (stateRef.current.bounds?.left || 0)) {
-              newState.left = deltaLeft;
-              newState.width = size.width + widthDelta;
-              containerElement.scrollLeft = newState.left;
-            } else {
-              newState.left = stateRef.current.bounds?.left || 0;
-            }
-          }
-        }
-        newState.resizeByScroll = false;
-      }
-      if (handle.includes("n")) {
-        stateRef.current.scrollTop = containerElement.scrollTop;
-        const deltaTop = stateRef.current.top - heightDelta;
-        if (yContainerPosition.isInside) {
-          if (deltaTop > (stateRef.current.bounds?.top || 0)) {
-            newState.top = deltaTop;
-            newState.height = size.height;
-            containerElement.scrollTop = newState.top;
-          } else {
-            newState.top = stateRef.current.bounds?.top || 0;
-          }
-        } else {
-          if (yNodePosition.isInStrip) {
-            if (deltaTop > (stateRef.current.bounds?.top || 0)) {
-              newState.top = deltaTop;
-              newState.height = size.height + heightDelta;
-              containerElement.scrollTop = newState.top;
-            } else {
-              newState.top = stateRef.current.bounds?.top || 0;
-            }
-          }
-        }
-        newState.resizeByScroll = false;
-      }
-      let newScrollLeft;
-      let newScrollTop;
-      if (handle.includes("e")) {
-        if (xContainerPosition.isInside || allowWidthResizeContainer) {
-          newState.width = size.width;
-          const right = newState.left + newState.width;
-          const containerViewportRight = containerElement.scrollLeft + containerElement.clientWidth;
-          if (right > containerViewportRight) {
-            newScrollLeft = right - containerElement.clientWidth;
-          }
-        } else {
-          if (xContainerPosition.isRight) {
-            newState.width = containerSize.containerWidth - newState.left + (stateRef.current.bounds?.right || 0);
-          }
-        }
-      }
-      if (handle.includes("s")) {
-        if (yContainerPosition.isInside || allowHeightResizeContainer) {
-          newState.height = size.height;
-          const bottom = newState.top + newState.height;
-          const containerViewportBottom = containerElement.scrollTop + containerElement.clientHeight;
-          if (bottom > containerViewportBottom) {
-            newScrollTop = bottom - containerElement.clientHeight + (handlerName !== "onResizeStop" ? 0 : 10);
-          }
-        } else {
-          if (yContainerPosition.isBelow) {
-            newState.height = containerSize.containerHeight - newState.top + (stateRef.current.bounds?.bottom || 0);
-          }
-        }
-      }
-      if (newScrollLeft !== void 0 || newScrollTop !== void 0) {
-        setTimeout(() => {
-          containerElement.scrollTo({
-            left: newScrollLeft,
-            top: newScrollTop,
-            behavior: "instant"
-          });
-        }, 5);
-      }
-      const resizing = handlerName === "onResizeStop" ? void 0 : {
-        ...size,
-        startClientX: stateRef.current.resizing?.startClientX,
-        startClientY: stateRef.current.resizing?.startClientY,
-        startHeight: stateRef.current.resizing?.startHeight,
-        startWidth: stateRef.current.resizing?.startWidth,
-        handle
-      };
-      setCurrentState({
-        ...newState,
-        resizing
-      });
-      stateRef.current = {
-        ...stateRef.current,
-        ...newState,
-        resizing
-      };
-    },
-    //OJO NO se puede poner a depender solo de props, porque en cada movimiento se regeneraria el useCallback
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [props["onResize"], props["onResizeStart"], props["onResizeStop"], containerElement, stateRef, setCurrentState, allowHeightResizeContainer, allowWidthResizeContainer]
-  );
-  const localOnResizeStart = useCallback(
-    (e, callbackData) => {
-      onResizeHandler(e, callbackData, "onResizeStart");
-    },
-    [onResizeHandler]
-  );
-  const localOnResize = useCallback(
-    (e, callbackData) => {
-      onResizeHandler(e, callbackData, "onResize");
-    },
-    [onResizeHandler]
-  );
-  const localOnResizeStop = useCallback(
-    (e, callbackData) => {
-      onResizeHandler(e, callbackData, "onResizeStop");
-      stateRef.current = {
-        ...stateRef.current,
-        ...callbackData.size,
-        resizing: void 0
-      };
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [onResizeHandler]
-  );
-  return { localOnResize, localOnResizeStart, localOnResizeStop };
-};
-export {
-  useResizeOptions as u
-};

package/components/DragResizeWindow/icons.d.ts

@@ -1,3 +0,0 @@
-export declare const ICONS: {
-    RESIZE: string;
-};

package/components/DragResizeWindow/index.d.ts

@@ -1,2 +0,0 @@
-export { DragResizeWindow } from './DragResizeWindow';
-export { dragResizeWindowClasses } from './classes/index';

package/components/DragResizeWindow/slots/DragResizeWindowSlots.d.ts

@@ -1,6 +0,0 @@
-export declare const RootStyled: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material/styles').Theme> & Record<string, unknown> & {
-    ownerState: Partial<import('../types').DragResizeWindowOwnerState> & Record<string, unknown>;
-}, Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').ClassAttributes<HTMLDivElement> | keyof import('react').HTMLAttributes<HTMLDivElement>>, {}>;
-export declare const IconResizeFormatterStyled: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material/styles').Theme> & Record<string, unknown> & {
-    ownerState: Partial<import('../types').DragResizeWindowOwnerState> & Record<string, unknown>;
-}, Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').ClassAttributes<HTMLDivElement> | keyof import('react').HTMLAttributes<HTMLDivElement>>, {}>;

package/components/DragResizeWindow/slots/DragResizeWindowSlots.js

@@ -1,14 +0,0 @@
-import { styled } from "@mui/material/styles";
-import { C as COMPONENT_KEY_COMPONENT } from "../constants.js";
-import { d as dragResizeWindowStyles } from "../DragResizeWindow.styles.js";
-import { D as DragResizeWindowSlots } from "./slots.js";
-const RootStyled = styled("div", { name: COMPONENT_KEY_COMPONENT, slot: DragResizeWindowSlots.root })(
-  dragResizeWindowStyles?.root
-);
-styled("div", {
-  name: COMPONENT_KEY_COMPONENT,
-  slot: DragResizeWindowSlots.iconResizeFormatterRoot
-})(dragResizeWindowStyles?.iconResizeFormatterRoot);
-export {
-  RootStyled as R
-};

package/components/DragResizeWindow/slots/slots.d.ts

@@ -1,4 +0,0 @@
-export declare enum DragResizeWindowSlots {
-    root = "root",
-    iconResizeFormatterRoot = "iconResizeFormatterRoot"
-}

package/components/DragResizeWindow/slots/slots.js

@@ -1,8 +0,0 @@
-var DragResizeWindowSlots = /* @__PURE__ */ ((DragResizeWindowSlots2) => {
-  DragResizeWindowSlots2["root"] = "root";
-  DragResizeWindowSlots2["iconResizeFormatterRoot"] = "iconResizeFormatterRoot";
-  return DragResizeWindowSlots2;
-})(DragResizeWindowSlots || {});
-export {
-  DragResizeWindowSlots as D
-};

package/components/DragResizeWindow/tests/DragResizeWindow.test.d.ts

@@ -1 +0,0 @@
-export {};