@cloudtower/eagle 0.0.0-double-rc-1 → 0.0.0-no-uikit-0

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

@@ -0,0 +1,122 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('@linaria/react');
+var index$9 = require('../../core/Bit/index.js');
+var index$8 = require('../../core/BitPerSecond/index.js');
+var index$7 = require('../../core/Bps/index.js');
+var index$4 = require('../../core/Byte/index.js');
+var index = require('../../core/Empty/index.js');
+var index$5 = require('../../core/Frequency/index.js');
+var index$2 = require('../../core/Percent/index.js');
+var index$a = require('../../core/Second/index.js');
+var index$6 = require('../../core/Speed/index.js');
+var index$1 = require('../BarChart/index.js');
+var index$3 = require('../DeprecatedDonutChart/index.js');
+var React = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(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: index$2,
+  Byte: index$4,
+  Frequency: index$5,
+  Speed: index$6,
+  Bps: index$7,
+  BitPerSecond: index$8,
+  Bit: index$9,
+  Second: index$a
+};
+const Wrapper = /*#__PURE__*/react.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.default.createElement(index, null);
+  }
+  const Unit = units[unit];
+  return /* @__PURE__ */React__default.default.createElement(Wrapper, {
+    className: "unit-chart"
+  }, chartType === "barChart" && /* @__PURE__ */React__default.default.createElement("span", {
+    className: BarChartWrapper
+  }, /* @__PURE__ */React__default.default.createElement("span", {
+    className: "chart"
+  }, /* @__PURE__ */React__default.default.createElement(index$1.default, {
+    data: data || [],
+    total
+  }))), /* @__PURE__ */React__default.default.createElement("span", {
+    className: UnitWrapper
+  }, unit === "Percent" ? /* @__PURE__ */React__default.default.createElement(index$2, {
+    rawValue,
+    decimals: 1,
+    saturated
+  }) : /* @__PURE__ */React__default.default.createElement(Unit, {
+    rawValue
+  })), chartType === "donutChart" && /* @__PURE__ */React__default.default.createElement(index$3, __spreadValues({
+    data: [{
+      used: rawValue / total,
+      fill: color
+    }],
+    dataKey: "used"
+  }, Sizes[size])));
+};
+var UnitWithChart$1 = UnitWithChart;
+
+exports.UnitWrapper = UnitWrapper;
+exports.default = UnitWithChart$1;

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

@@ -0,0 +1,26 @@
+'use strict';
+
+var parrot = require('@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 === parrot.ParrotLngs.zh) {
+    return `${month} ${t("common.month")}`;
+  }
+  return MonthText[month];
+}
+
+exports.getCalendarTitle = getCalendarTitle;

package/dist/cjs/hooks/useElementIntersectionRatio.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var React = require('react');
+
+const threshold = new Array(101).fill(1).map((value, index) => index / 100);
+function useElementIntersectionRatio(el, parent) {
+  const [entry, setEntry] = React.useState(null);
+  React.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;
+}
+
+module.exports = useElementIntersectionRatio;

package/dist/cjs/hooks/useElementResize.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var _ = require('lodash');
+var React = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ___default = /*#__PURE__*/_interopDefault(_);
+
+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 (!___default.default.isEqual(nextOffsetWidth, data.offsetWidth) || ___default.default.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);
+  React.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;
+
+module.exports = useElementResize$1;

package/dist/cjs/hooks/useElementsSize.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var _ = require('lodash');
+var React = require('react');
+var dom = require('../utils/dom.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ___default = /*#__PURE__*/_interopDefault(_);
+
+function getAllSize(classMap) {
+  return Object.keys(classMap).reduce((prev, cur) => {
+    prev[cur] = dom.getSize(
+      document.querySelector(classMap[cur])
+    );
+    return prev;
+  }, {});
+}
+const elementsSizes = {};
+function useElementsSize(classMap, config) {
+  const { prevent, key, dependencyList } = config;
+  const preSizes = React.useRef();
+  const [sizes, setSizes] = React.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 = React.useRef(classMap);
+  classMapRef.current = classMap;
+  const handleResize = React.useCallback(() => {
+    if (prevent)
+      return;
+    const nextSizes = getAllSize(classMapRef.current);
+    if (key) {
+      if (!elementsSizes[key] || // FIXME: antd 4.0 table thead will be delay render
+      !___default.default.isEqual(
+        ___default.default.omit(elementsSizes[key], "thead"),
+        ___default.default.omit(nextSizes, "thead")
+      )) {
+        elementsSizes[key] = nextSizes;
+        setSizes(nextSizes);
+      }
+    } else if (!___default.default.isEqual(preSizes.current, nextSizes)) {
+      preSizes.current = nextSizes;
+      setSizes(nextSizes);
+    }
+  }, [prevent, key, ...dependencyList || []]);
+  React.useLayoutEffect(() => {
+    handleResize();
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, [handleResize]);
+  return sizes;
+}
+
+module.exports = useElementsSize;

package/dist/cjs/hooks/useMemoCompare.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var React = require('react');
+
+function useMemoCompare(next, compare) {
+  const previousRef = React.useRef();
+  const previous = previousRef.current;
+  const isEqual = compare(previous, next);
+  React.useEffect(() => {
+    if (!isEqual) {
+      previousRef.current = next;
+    }
+  });
+  return isEqual ? previous : next;
+}
+
+module.exports = useMemoCompare;

package/dist/cjs/hooks/useParrotTranslation.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var parrot = require('@cloudtower/parrot');
+var reactI18next = require('react-i18next');
+
+const useParrotTranslation = () => {
+  return reactI18next.useTranslation(void 0, {
+    i18n: parrot.parrotI18n
+  });
+};
+var useParrotTranslation$1 = useParrotTranslation;
+
+module.exports = useParrotTranslation$1;