@cloudtower/eagle 0.27.53 → 0.27.55

package/dist/esm/hooks/useElementIntersectionRatio.js

@@ -0,0 +1,28 @@
+import { useState, useEffect } from 'react';
+
+const threshold = new Array(101).fill(1).map((value, index) => index / 100);
+function useElementIntersectionRatio(el, parent) {
+  const [entry, setEntry] = useState(null);
+  useEffect(() => {
+    if (!el.current) {
+      return;
+    }
+    const observer = new IntersectionObserver(
+      (entries) => {
+        setEntry(entries[0] || null);
+      },
+      {
+        threshold,
+        root: (parent == null ? void 0 : parent.current) || document.body,
+        rootMargin: "-32px 0px 0px 0px"
+      }
+    );
+    observer.observe(el.current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [el, parent]);
+  return entry;
+}
+
+export { useElementIntersectionRatio as default };

package/dist/esm/hooks/useElementResize.js

@@ -0,0 +1,67 @@
+import _ from 'lodash';
+import { useEffect } from 'react';
+
+const transformToArray = (stringOrArray) => {
+  return stringOrArray instanceof Array ? stringOrArray : [stringOrArray];
+};
+const onResizeElem = (element, callback) => {
+  const els = transformToArray(element);
+  const data = {
+    els,
+    offsetWidth: els.map((el) => el.offsetWidth),
+    offsetHeight: els.map((el) => el.offsetHeight),
+    callback
+  };
+  const checkForChanges = () => {
+    const nextOffsetWidth = data.els.map((el) => el.offsetWidth);
+    const nextOffsetHeight = data.els.map((el) => el.offsetWidth);
+    if (!_.isEqual(nextOffsetWidth, data.offsetWidth) || _.isEqual(nextOffsetHeight, data.offsetHeight)) {
+      data.offsetWidth = nextOffsetWidth;
+      data.offsetHeight = nextOffsetHeight;
+      data.callback();
+    }
+  };
+  const mutationObserver = new MutationObserver(checkForChanges);
+  mutationObserver.observe(document.body, {
+    attributes: true,
+    subtree: true
+  });
+  window.addEventListener("resize", checkForChanges);
+  const disconnect = () => {
+    window.removeEventListener("resize", checkForChanges);
+    mutationObserver.disconnect();
+  };
+  return disconnect;
+};
+const useElementResize = (klass, cb, depend) => {
+  const klasses = transformToArray(klass);
+  useEffect(() => {
+    let els = [];
+    if (typeof klass === "object" && "current" in klass) {
+      els = klass.current ? [klass.current] : [];
+    } else {
+      klasses.forEach((klass2) => {
+        const arr = Array.from(
+          document.querySelectorAll(klass2)
+        );
+        if (arr.length > 0) {
+          els = [...els, ...arr];
+        }
+      });
+    }
+    if (!els.length)
+      return;
+    if (typeof ResizeObserver === "function") {
+      const resizeObserver = new ResizeObserver(cb);
+      els.forEach((el) => {
+        resizeObserver.observe(el);
+      });
+      return () => resizeObserver.disconnect();
+    } else {
+      return onResizeElem(Array.from(els), cb);
+    }
+  }, [cb, ...depend || []]);
+};
+var useElementResize$1 = useElementResize;
+
+export { useElementResize$1 as default };

package/dist/esm/hooks/useElementsSize.js

@@ -0,0 +1,56 @@
+import _ from 'lodash';
+import { useRef, useState, useCallback, useLayoutEffect } from 'react';
+import { getSize } from '../utils/dom.js';
+
+function getAllSize(classMap) {
+  return Object.keys(classMap).reduce((prev, cur) => {
+    prev[cur] = getSize(
+      document.querySelector(classMap[cur])
+    );
+    return prev;
+  }, {});
+}
+const elementsSizes = {};
+function useElementsSize(classMap, config) {
+  const { prevent, key, dependencyList } = config;
+  const preSizes = useRef();
+  const [sizes, setSizes] = useState(() => {
+    if (key && elementsSizes[key]) {
+      return elementsSizes[key];
+    }
+    const initSizes = Object.keys(classMap).reduce((prev, cur) => {
+      prev[cur] = { width: 0, height: 0 };
+      return prev;
+    }, {});
+    preSizes.current = initSizes;
+    return initSizes;
+  });
+  const classMapRef = useRef(classMap);
+  classMapRef.current = classMap;
+  const handleResize = useCallback(() => {
+    if (prevent)
+      return;
+    const nextSizes = getAllSize(classMapRef.current);
+    if (key) {
+      if (!elementsSizes[key] || // FIXME: antd 4.0 table thead will be delay render
+      !_.isEqual(
+        _.omit(elementsSizes[key], "thead"),
+        _.omit(nextSizes, "thead")
+      )) {
+        elementsSizes[key] = nextSizes;
+        setSizes(nextSizes);
+      }
+    } else if (!_.isEqual(preSizes.current, nextSizes)) {
+      preSizes.current = nextSizes;
+      setSizes(nextSizes);
+    }
+  }, [prevent, key, ...dependencyList || []]);
+  useLayoutEffect(() => {
+    handleResize();
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [handleResize]);
+  return sizes;
+}
+
+export { useElementsSize as default };

package/dist/esm/hooks/useMemoCompare.js

@@ -0,0 +1,15 @@
+import { useRef, useEffect } from 'react';
+
+function useMemoCompare(next, compare) {
+  const previousRef = useRef();
+  const previous = previousRef.current;
+  const isEqual = compare(previous, next);
+  useEffect(() => {
+    if (!isEqual) {
+      previousRef.current = next;
+    }
+  });
+  return isEqual ? previous : next;
+}
+
+export { useMemoCompare as default };

package/dist/esm/hooks/useParrotTranslation.js

@@ -0,0 +1,11 @@
+import { parrotI18n } from '@cloudtower/parrot';
+import { useTranslation } from 'react-i18next';
+
+const useParrotTranslation = () => {
+  return useTranslation(void 0, {
+    i18n: parrotI18n
+  });
+};
+var useParrotTranslation$1 = useParrotTranslation;
+
+export { useParrotTranslation$1 as default };