@synerise/ds-utils 1.6.0 → 1.7.1

package/dist/useDelimiterEscape/useDelimiterEscape.js

@@ -1,48 +1,33 @@
-import { useMemo } from 'react';
-export var useDelimiterEscape = function useDelimiterEscape(config) {
-  if (config === void 0) {
-    config = {};
-  }
-  var _config = config,
-    _config$delimiter = _config.delimiter,
-    delimiter = _config$delimiter === void 0 ? ',' : _config$delimiter,
-    _config$openTag = _config.openTag,
-    openTag = _config$openTag === void 0 ? '```' : _config$openTag,
-    _config$closeTag = _config.closeTag,
-    closeTag = _config$closeTag === void 0 ? '```' : _config$closeTag;
-  return useMemo(function () {
-    var joinWithEscape = function joinWithEscape(items) {
-      return items.map(function (item) {
-        return item.includes(delimiter) ? "" + openTag + item + closeTag : item;
-      }).join(delimiter);
+import { useMemo } from "react";
+const useDelimiterEscape = (config = {}) => {
+  const {
+    delimiter = ",",
+    openTag = "```",
+    closeTag = "```"
+  } = config;
+  return useMemo(() => {
+    const joinWithEscape = (items) => {
+      return items.map((item) => item.includes(delimiter) ? `${openTag}${item}${closeTag}` : item).join(delimiter);
     };
-    var splitWithEscape = function splitWithEscape(input) {
-      var result = [];
-      var i = 0;
-      var openTagLen = openTag.length;
-      var closeTagLen = closeTag.length;
+    const splitWithEscape = (input) => {
+      const result = [];
+      let i = 0;
+      const openTagLen = openTag.length;
+      const closeTagLen = closeTag.length;
       while (i < input.length) {
-        var current = '';
-
-        // Check if we're at the start of a potential opening sequence
+        let current = "";
         if (input.substring(i, i + openTagLen) === openTag) {
-          var validOpening = i === 0 || input[i - 1] === delimiter;
+          const validOpening = i === 0 || input[i - 1] === delimiter;
           if (validOpening) {
-            // This is a valid opening - consume the opening tag
             i += openTagLen;
-            current = '';
-
-            // Find the closing tag (must be followed by delimiter or at end)
+            current = "";
             while (i < input.length) {
               if (input.substring(i, i + closeTagLen) === closeTag) {
-                // Check if this is a valid closing
-                var validClosing = i + closeTagLen === input.length || input[i + closeTagLen] === delimiter;
+                const validClosing = i + closeTagLen === input.length || input[i + closeTagLen] === delimiter;
                 if (validClosing) {
-                  // Found closing tag
                   i += closeTagLen;
                   break;
                 } else {
-                  // Not a valid closing - treat as content
                   current += input[i];
                   i++;
                 }
@@ -51,10 +36,8 @@ export var useDelimiterEscape = function useDelimiterEscape(config) {
                 i++;
               }
             }
-            // Push the item without the wrapper tags
             result.push(current);
           } else {
-            // Not a valid opening - treat as regular item
             while (i < input.length && input[i] !== delimiter) {
               current += input[i];
               i++;
@@ -64,7 +47,6 @@ export var useDelimiterEscape = function useDelimiterEscape(config) {
             }
           }
         } else {
-          // Regular item - consume until delimiter
           while (i < input.length && input[i] !== delimiter) {
             current += input[i];
             i++;
@@ -73,49 +55,38 @@ export var useDelimiterEscape = function useDelimiterEscape(config) {
             result.push(current);
           }
         }
-
-        // Skip the delimiter
         if (i < input.length && input[i] === delimiter) {
           i++;
         }
       }
       return result;
     };
-    var isValidEscapedString = function isValidEscapedString(input) {
-      var inEscapeBlock = false;
-      var i = 0;
-      var openTagLen = openTag.length;
-      var closeTagLen = closeTag.length;
-      var delimiterLen = delimiter.length;
+    const isValidEscapedString = (input) => {
+      let inEscapeBlock = false;
+      let i = 0;
+      const openTagLen = openTag.length;
+      const closeTagLen = closeTag.length;
+      const delimiterLen = delimiter.length;
       while (i < input.length) {
         if (!inEscapeBlock) {
-          // Not in escape block - look for opening tag
           if (input.substring(i, i + openTagLen) === openTag) {
-            // Check if this is a valid opening position
-            var validOpening = i === 0 || input.substring(i - delimiterLen, i) === delimiter;
+            const validOpening = i === 0 || input.substring(i - delimiterLen, i) === delimiter;
             if (validOpening) {
-              // Valid opening position - enter escape block
               inEscapeBlock = true;
               i += openTagLen;
             } else {
-              // Not a valid opening position - treat as regular content
               i++;
             }
           } else {
             i++;
           }
         } else {
-          // In escape block - look for closing tag
           if (input.substring(i, i + closeTagLen) === closeTag) {
-            // Check if this is a valid closing
-            // Valid closing: at end of string or followed by delimiter
-            var validClosing = i + closeTagLen === input.length || input.substring(i + closeTagLen, i + closeTagLen + delimiterLen) === delimiter;
+            const validClosing = i + closeTagLen === input.length || input.substring(i + closeTagLen, i + closeTagLen + delimiterLen) === delimiter;
             if (validClosing) {
-              // This is a closing tag
               inEscapeBlock = false;
               i += closeTagLen;
             } else {
-              // Not a valid closing - treat as regular content
               i++;
             }
           } else {
@@ -123,14 +94,15 @@ export var useDelimiterEscape = function useDelimiterEscape(config) {
           }
         }
       }
-
-      // Invalid if we're still inside an escape block (unclosed opening tag)
       return !inEscapeBlock;
     };
     return {
-      joinWithEscape: joinWithEscape,
-      splitWithEscape: splitWithEscape,
-      isValidEscapedString: isValidEscapedString
+      joinWithEscape,
+      splitWithEscape,
+      isValidEscapedString
     };
   }, [delimiter, openTag, closeTag]);
-};
+};
+export {
+  useDelimiterEscape
+};

package/dist/useElementInView/useElementInView.d.ts

@@ -1,11 +1,11 @@
-import { type MutableRefObject } from 'react';
+import { MutableRefObject } from 'react';
 type IntersectionObserverOptions = {
     rootMargin?: string;
     threshold?: number | number[];
 };
 declare const useElementInView: <T extends HTMLElement = HTMLElement>(options: IntersectionObserverOptions, rootElementRef?: MutableRefObject<HTMLDivElement | null | undefined>) => {
     isIntersecting: boolean;
-    elementRef: import("react").RefObject<T>;
+    elementRef: import('react').RefObject<T>;
     isVisible: boolean;
 };
 export default useElementInView;

package/dist/useElementInView/useElementInView.js

@@ -1,28 +1,27 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import { useEffect, useRef, useState } from 'react';
-var useElementInView = function useElementInView(options, rootElementRef) {
-  var elementRef = useRef(null);
-  var _useState = useState(false),
-    isVisible = _useState[0],
-    setIsVisible = _useState[1];
-  useEffect(function () {
-    var intersectionObserver = new IntersectionObserver(function (_ref) {
-      var entry = _ref[0];
+import { useRef, useState, useEffect } from "react";
+const useElementInView = (options, rootElementRef) => {
+  const elementRef = useRef(null);
+  const [isVisible, setIsVisible] = useState(false);
+  useEffect(() => {
+    const intersectionObserver = new IntersectionObserver(([entry]) => {
       setIsVisible(entry.isIntersecting);
-    }, _extends({}, options, {
-      root: (rootElementRef == null ? void 0 : rootElementRef.current) || null
-    }));
+    }, {
+      ...options,
+      root: rootElementRef?.current || null
+    });
     if (elementRef.current) {
       intersectionObserver.observe(elementRef.current);
     }
-    return function () {
+    return () => {
       intersectionObserver.disconnect();
     };
   });
   return {
     isIntersecting: isVisible,
-    elementRef: elementRef,
-    isVisible: isVisible
+    elementRef,
+    isVisible
   };
 };
-export default useElementInView;
+export {
+  useElementInView as default
+};

package/dist/useIsMounted/useIsMounted.d.ts

@@ -1 +1 @@
-export declare const useIsMounted: () => import("react").MutableRefObject<boolean>;
+export declare const useIsMounted: () => import('react').MutableRefObject<boolean>;

package/dist/useIsMounted/useIsMounted.js

@@ -1,11 +1,14 @@
-import { useEffect, useRef } from 'react';
-export var useIsMounted = function useIsMounted() {
-  var isMounted = useRef(false);
-  useEffect(function () {
+import { useRef, useEffect } from "react";
+const useIsMounted = () => {
+  const isMounted = useRef(false);
+  useEffect(() => {
     isMounted.current = true;
-    return function () {
+    return () => {
       isMounted.current = false;
     };
   }, []);
   return isMounted;
-};
+};
+export {
+  useIsMounted
+};

package/dist/useKeyboardShortcuts/useKeyboardShortcuts.js

@@ -1,12 +1,15 @@
-import { useEffect } from 'react';
-export var useKeyboardShortcuts = function useKeyboardShortcuts(keyConfig) {
-  useEffect(function () {
-    var keyboardShortcuts = function keyboardShortcuts(event) {
+import { useEffect } from "react";
+const useKeyboardShortcuts = (keyConfig) => {
+  useEffect(() => {
+    const keyboardShortcuts = (event) => {
       keyConfig[event.key] && keyConfig[event.key](event);
     };
-    document.addEventListener('keydown', keyboardShortcuts);
-    return function () {
-      document.removeEventListener('keydown', keyboardShortcuts);
+    document.addEventListener("keydown", keyboardShortcuts);
+    return () => {
+      document.removeEventListener("keydown", keyboardShortcuts);
     };
   }, [keyConfig]);
-};
+};
+export {
+  useKeyboardShortcuts
+};

package/dist/useLatestRef/index.js

@@ -1 +1,4 @@
-export * from './useLatestRef';
+import { useLatestRef } from "./useLatestRef.js";
+export {
+  useLatestRef
+};

package/dist/useLatestRef/useLatestRef.d.ts

@@ -1 +1 @@
-export declare const useLatestRef: <T>(value: T) => import("react").MutableRefObject<T>;
+export declare const useLatestRef: <T>(value: T) => import('react').MutableRefObject<T>;

package/dist/useLatestRef/useLatestRef.js

@@ -1,8 +1,11 @@
-import { useEffect, useRef } from 'react';
-export var useLatestRef = function useLatestRef(value) {
-  var ref = useRef(value);
-  useEffect(function () {
+import { useRef, useEffect } from "react";
+const useLatestRef = (value) => {
+  const ref = useRef(value);
+  useEffect(() => {
     ref.current = value;
   }, [value]);
   return ref;
-};
+};
+export {
+  useLatestRef
+};

package/dist/useOnClickOutside/useOnClickOutside.d.ts

@@ -1,4 +1,4 @@
-import { type RefObject } from 'react';
+import { RefObject } from 'react';
 declare const MOUSEDOWN = "mousedown";
 declare const TOUCHSTART = "touchstart";
 declare const _CLICK = "click";

package/dist/useOnClickOutside/useOnClickOutside.js

@@ -1,53 +1,39 @@
-import { useEffect, useRef } from 'react';
-var MOUSEDOWN = 'mousedown';
-var TOUCHSTART = 'touchstart';
-var _CLICK = 'click';
-var _CONTEXTMENU = 'contextmenu';
-var defaultEvents = [MOUSEDOWN, TOUCHSTART];
-
-/**
- * Hook for listening for outside clicks.
- *
- * @param ref main component to out of which outside clicks will be detected
- * @param handler function called on outside click
- * @param customEventsTypes list of events to handle that are happening outside (optional, pass something else than `undefined` to overwrite default `['mousedown', 'touchstart']`)
- * @param ignoreSelectors list of selectors/classes which, in case it is found that any of parent elements of triggering element has this class, event `handler` won't be called
- */
-export var useOnClickOutside = function useOnClickOutside(ref, handler, customEventsTypes, ignoreSelectors) {
-  var handlerRef = useRef(handler);
-  var events = customEventsTypes || defaultEvents;
-  useEffect(function () {
+import { useRef, useEffect } from "react";
+const MOUSEDOWN = "mousedown";
+const TOUCHSTART = "touchstart";
+const defaultEvents = [MOUSEDOWN, TOUCHSTART];
+const useOnClickOutside = (ref, handler, customEventsTypes, ignoreSelectors) => {
+  const handlerRef = useRef(handler);
+  const events = customEventsTypes || defaultEvents;
+  useEffect(() => {
     handlerRef.current = handler;
   });
-  useEffect(function () {
+  useEffect(() => {
     if (!handler) {
-      return function () {
-        return null;
-      };
+      return () => null;
     }
-    var listener = function listener(event) {
+    const listener = (event) => {
       if (!ref.current || !handlerRef.current) {
         return;
       }
       if (ref.current.contains(event.target)) {
         return;
       }
-      if (ignoreSelectors != null && ignoreSelectors.some(function (className) {
-        var _event$target;
-        return (_event$target = event.target) == null ? void 0 : _event$target.closest(className);
-      })) {
-        // if any of parent elements contain one of ignored classes - stop proceeding this event
+      if (ignoreSelectors?.some((className) => event.target?.closest(className))) {
         return;
       }
       handlerRef.current(event);
     };
-    events.forEach(function (event) {
+    events.forEach((event) => {
       document.addEventListener(event, listener);
     });
-    return function () {
-      events.forEach(function (event) {
+    return () => {
+      events.forEach((event) => {
         document.removeEventListener(event, listener);
       });
     };
   }, [handler, ref, events, ignoreSelectors]);
-};
+};
+export {
+  useOnClickOutside
+};

package/dist/useOverscrollBlock/useOverscrollBlock.d.ts

@@ -1,2 +1,2 @@
-declare const useOverscrollBlock: <T extends HTMLElement>() => import("react").MutableRefObject<T | undefined>;
+declare const useOverscrollBlock: <T extends HTMLElement>() => import('react').MutableRefObject<T | undefined>;
 export default useOverscrollBlock;

package/dist/useOverscrollBlock/useOverscrollBlock.js

@@ -1,26 +1,28 @@
-import { useCallback, useEffect, useRef } from 'react';
-var useOverscrollBlock = function useOverscrollBlock() {
-  var ref = useRef();
-  var handleMouseEnter = useCallback(function () {
-    document.body.style.overscrollBehaviorX = 'contain';
+import { useRef, useCallback, useEffect } from "react";
+const useOverscrollBlock = () => {
+  const ref = useRef();
+  const handleMouseEnter = useCallback(() => {
+    document.body.style.overscrollBehaviorX = "contain";
   }, []);
-  var handleMouseLeave = useCallback(function () {
-    document.body.style.removeProperty('overscroll-behavior-x');
+  const handleMouseLeave = useCallback(() => {
+    document.body.style.removeProperty("overscroll-behavior-x");
   }, []);
-  useEffect(function () {
-    var element = ref.current;
+  useEffect(() => {
+    const element = ref.current;
     if (element) {
-      element.addEventListener('mouseenter', handleMouseEnter);
-      element.addEventListener('mouseleave', handleMouseLeave);
+      element.addEventListener("mouseenter", handleMouseEnter);
+      element.addEventListener("mouseleave", handleMouseLeave);
     }
-    return function () {
+    return () => {
       if (element) {
-        element.removeEventListener('mouseenter', handleMouseEnter);
-        element.removeEventListener('mouseleave', handleMouseLeave);
+        element.removeEventListener("mouseenter", handleMouseEnter);
+        element.removeEventListener("mouseleave", handleMouseLeave);
       }
-      document.body.style.removeProperty('overscroll-behavior-x');
+      document.body.style.removeProperty("overscroll-behavior-x");
     };
   }, [handleMouseEnter, handleMouseLeave]);
   return ref;
 };
-export default useOverscrollBlock;
+export {
+  useOverscrollBlock as default
+};

package/dist/usePrevious/usePrevious.js

@@ -1,9 +1,11 @@
-import React from 'react';
+import React from "react";
 function usePrevious(value) {
-  var ref = React.useRef();
-  React.useEffect(function () {
+  const ref = React.useRef();
+  React.useEffect(() => {
     ref.current = value;
   });
   return ref.current;
 }
-export default usePrevious;
+export {
+  usePrevious as default
+};

package/dist/useResize/useResize.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import { default as React } from 'react';
 type Dimensions = {
     width: number;
     height: number;

package/dist/useResize/useResize.js

@@ -1,33 +1,27 @@
-import React from 'react';
-var useResize = function useResize(componentRef, visible) {
-  if (visible === void 0) {
-    visible = true;
-  }
-  var _React$useState = React.useState({
-      width: 0,
-      height: 0
-    }),
-    dimensions = _React$useState[0],
-    setDimensions = _React$useState[1];
-  React.useEffect(function () {
-    var getDimensions = function getDimensions() {
-      var _componentRef$current, _componentRef$current2;
-      return {
-        width: (componentRef == null || (_componentRef$current = componentRef.current) == null ? void 0 : _componentRef$current.offsetWidth) || 0,
-        height: (componentRef == null || (_componentRef$current2 = componentRef.current) == null ? void 0 : _componentRef$current2.offsetHeight) || 0
-      };
-    };
-    var handleResize = function handleResize() {
+import React from "react";
+const useResize = (componentRef, visible = true) => {
+  const [dimensions, setDimensions] = React.useState({
+    width: 0,
+    height: 0
+  });
+  React.useEffect(() => {
+    const getDimensions = () => ({
+      width: componentRef?.current?.offsetWidth || 0,
+      height: componentRef?.current?.offsetHeight || 0
+    });
+    const handleResize = () => {
       setDimensions(getDimensions());
     };
-    if (componentRef != null && componentRef.current) {
+    if (componentRef?.current) {
       setDimensions(getDimensions());
     }
-    window.addEventListener('resize', handleResize);
-    return function () {
-      window.removeEventListener('resize', handleResize);
+    window.addEventListener("resize", handleResize);
+    return () => {
+      window.removeEventListener("resize", handleResize);
     };
   }, [componentRef, setDimensions, visible]);
   return dimensions;
 };
-export default useResize;
+export {
+  useResize as default
+};

package/dist/useResizeObserver/useResizeObserver.d.ts

@@ -1,3 +1,3 @@
-import { type RefObject } from 'react';
+import { RefObject } from 'react';
 declare const useResizeObserver: (elementRef: RefObject<HTMLElement | undefined>, resizeHandler?: (dimensions: DOMRect) => void) => DOMRect;
 export default useResizeObserver;

package/dist/useResizeObserver/useResizeObserver.js

@@ -1,36 +1,36 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-var useResizeObserver = function useResizeObserver(elementRef, resizeHandler) {
-  var _useState = useState(new DOMRect()),
-    dimensions = _useState[0],
-    setDimensions = _useState[1];
-  var resizeObserver = useRef(new ResizeObserver(function (entries) {
-    var runHandler = function runHandler() {
-      var contentRect = entries[0].contentRect;
+import { useState, useRef, useCallback, useEffect } from "react";
+const useResizeObserver = (elementRef, resizeHandler) => {
+  const [dimensions, setDimensions] = useState(new DOMRect());
+  const resizeObserver = useRef(new ResizeObserver((entries) => {
+    const runHandler = () => {
+      const {
+        contentRect
+      } = entries[0];
       setDimensions(contentRect);
       resizeHandler && resizeHandler(contentRect);
     };
-    if ('requestAnimationFrame' in window) {
+    if ("requestAnimationFrame" in window) {
       window.requestAnimationFrame(runHandler);
     } else {
       setTimeout(runHandler, 0);
     }
   })).current;
-  var observe = useCallback(function () {
+  const observe = useCallback(() => {
     elementRef.current && resizeObserver.observe(elementRef.current);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [resizeObserver]);
-  var disconnect = useCallback(function () {
+  const disconnect = useCallback(() => {
     resizeObserver.disconnect();
   }, [resizeObserver]);
-  useEffect(function () {
+  useEffect(() => {
     if (elementRef.current) {
       observe();
     }
-    return function () {
+    return () => {
       resizeObserver.disconnect();
     };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [resizeObserver, observe, disconnect]);
   return dimensions;
 };
-export default useResizeObserver;
+export {
+  useResizeObserver as default
+};

package/dist/useResizeToFit/useResizeToFit.d.ts

@@ -3,7 +3,7 @@ type useResizeToFitProps = {
     autoObserve?: boolean;
 };
 declare const useResizeToFit: <T extends HTMLElement = HTMLDivElement>({ onResize, autoObserve, }: useResizeToFitProps) => {
-    elementRef: import("react").RefObject<T>;
+    elementRef: import('react').RefObject<T>;
     disconnect: () => void;
     observe: () => void;
 };

package/dist/useResizeToFit/useResizeToFit.js

@@ -1,18 +1,19 @@
-import { useCallback, useEffect, useRef } from 'react';
-var useResizeToFit = function useResizeToFit(_ref) {
-  var onResize = _ref.onResize,
-    autoObserve = _ref.autoObserve;
-  var elementRef = useRef(null);
-  var resizeObserver = useRef(new ResizeObserver(function () {
+import { useRef, useCallback, useEffect } from "react";
+const useResizeToFit = ({
+  onResize,
+  autoObserve
+}) => {
+  const elementRef = useRef(null);
+  const resizeObserver = useRef(new ResizeObserver(() => {
     elementRef.current && onResize(elementRef.current.clientWidth);
   })).current;
-  var observe = useCallback(function () {
+  const observe = useCallback(() => {
     elementRef.current && resizeObserver.observe(elementRef.current);
   }, [resizeObserver]);
-  var disconnect = useCallback(function () {
+  const disconnect = useCallback(() => {
     resizeObserver.disconnect();
   }, [resizeObserver]);
-  useEffect(function () {
+  useEffect(() => {
     if (elementRef.current) {
       if (autoObserve) {
         observe();
@@ -20,14 +21,16 @@ var useResizeToFit = function useResizeToFit(_ref) {
         disconnect();
       }
     }
-    return function () {
+    return () => {
       resizeObserver.disconnect();
     };
   }, [resizeObserver, autoObserve, elementRef, observe, disconnect]);
   return {
-    elementRef: elementRef,
-    disconnect: disconnect,
-    observe: observe
+    elementRef,
+    disconnect,
+    observe
   };
 };
-export default useResizeToFit;
+export {
+  useResizeToFit as default
+};

package/dist/useScrollContain/useScrollContain.d.ts

@@ -1 +1 @@
-export declare const useScrollContain: <ElementType extends HTMLElement>() => import("react").RefObject<ElementType>;
+export declare const useScrollContain: <ElementType extends HTMLElement>() => import('react').RefObject<ElementType>;