@cloudtower/eagle 0.28.0-dry → 0.28.0

package/dist/esm/coreX/UnitWithChart/index.js

@@ -0,0 +1,113 @@
+import { styled } from '@linaria/react';
+import Bit from '../../core/Bit/index.js';
+import BitPerSecond from '../../core/BitPerSecond/index.js';
+import Bps from '../../core/Bps/index.js';
+import Byte from '../../core/Byte/index.js';
+import Empty from '../../core/Empty/index.js';
+import Frequency from '../../core/Frequency/index.js';
+import Percent from '../../core/Percent/index.js';
+import Second from '../../core/Second/index.js';
+import Speed from '../../core/Speed/index.js';
+import BarChart from '../BarChart/index.js';
+import DeprecatedDonutChart from '../DeprecatedDonutChart/index.js';
+import React__default from 'react';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {})) if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)) {
+    if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+  }
+  return a;
+};
+const units = {
+  Percent,
+  Byte,
+  Frequency,
+  Speed,
+  Bps,
+  BitPerSecond,
+  Bit,
+  Second
+};
+const Wrapper = /*#__PURE__*/styled('div')({
+  name: "Wrapper",
+  class: "E_wg1tsps",
+  propsAsIs: false
+});
+const BarChartWrapper = "E_b1ctd5xy";
+const UnitWrapper = "E_u1p8acpn";
+const Sizes = {
+  small: {
+    width: 22,
+    height: 22,
+    barSize: 4,
+    innerRadius: 8,
+    outerRadius: 16
+  },
+  medium: {
+    width: 50,
+    height: 50,
+    barSize: 8,
+    innerRadius: 18,
+    outerRadius: 34
+  },
+  large: {
+    width: 100,
+    height: 100,
+    barSize: 15,
+    innerRadius: 40,
+    outerRadius: 70
+  }
+};
+const UnitWithChart = ({
+  rawValue,
+  total,
+  unit,
+  color = "#0080FF",
+  size = "small",
+  chartType = "donutChart",
+  data,
+  saturated
+}) => {
+  if (typeof rawValue !== "number" || typeof total !== "number") {
+    return /* @__PURE__ */React__default.createElement(Empty, null);
+  }
+  const Unit = units[unit];
+  return /* @__PURE__ */React__default.createElement(Wrapper, {
+    className: "unit-chart"
+  }, chartType === "barChart" && /* @__PURE__ */React__default.createElement("span", {
+    className: BarChartWrapper
+  }, /* @__PURE__ */React__default.createElement("span", {
+    className: "chart"
+  }, /* @__PURE__ */React__default.createElement(BarChart, {
+    data: data || [],
+    total
+  }))), /* @__PURE__ */React__default.createElement("span", {
+    className: UnitWrapper
+  }, unit === "Percent" ? /* @__PURE__ */React__default.createElement(Percent, {
+    rawValue,
+    decimals: 1,
+    saturated
+  }) : /* @__PURE__ */React__default.createElement(Unit, {
+    rawValue
+  })), chartType === "donutChart" && /* @__PURE__ */React__default.createElement(DeprecatedDonutChart, __spreadValues({
+    data: [{
+      used: rawValue / total,
+      fill: color
+    }],
+    dataKey: "used"
+  }, Sizes[size])));
+};
+var UnitWithChart$1 = UnitWithChart;
+
+export { UnitWrapper, UnitWithChart$1 as default };

package/dist/esm/coreX/common/getCalendarTitle.js

@@ -0,0 +1,24 @@
+import { ParrotLngs } from '@cloudtower/parrot';
+
+const MonthText = {
+  "1": "January",
+  "2": "February",
+  "3": "March",
+  "4": "April",
+  "5": "May",
+  "6": "June",
+  "7": "July",
+  "8": "August",
+  "9": "September",
+  "10": "October",
+  "11": "November",
+  "12": "December"
+};
+function getCalendarTitle(month, t, i18n2) {
+  if (i18n2.language === ParrotLngs.zh) {
+    return `${month} ${t("common.month")}`;
+  }
+  return MonthText[month];
+}
+
+export { getCalendarTitle };

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 };