@cloudtower/eagle 0.0.0-config-rc-9 → 0.0.0-data-testid

package/dist/cjs/store/modal.js

@@ -24,6 +24,7 @@ var ModalActions = /* @__PURE__ */ ((ModalActions2) => {
   ModalActions2["POP_MODAL"] = "POP_MODAL";
   ModalActions2["REMOVE_MODAL"] = "REMOVE_MODAL";
   ModalActions2["CLOSE_MODAL"] = "CLOSE_MODAL";
+  ModalActions2["RESET_MODAL"] = "RESET_MODAL";
   return ModalActions2;
 })(ModalActions || {});
 const initialModalState = {
@@ -57,6 +58,8 @@ const modalReducer = (state = initialModalState, action) => {
       return __spreadProps(__spreadValues({}, state), {
         closeId: action.id
       });
+    case "RESET_MODAL" /* RESET_MODAL */:
+      return initialModalState;
     default:
       return state;
   }

package/dist/cjs/styles/token/animation.js

@@ -1,7 +1,28 @@
 'use strict';
 
 const Animation = {
-  loading: "loading 1600ms ease-out infinite"
+  loading: "loading 1600ms ease-out infinite",
+  circleRotate: "rotate 1200ms cubic-bezier(0.33, 0, 0.67, 1) infinite",
+  shimmer: "shimmer 1100ms infinite"
+};
+const Keyframes = {
+  rotate: `
+    @keyframes rotate {
+      from { transform: rotate(0deg); }
+      to { transform: rotate(360deg); }
+    }
+  `,
+  shimmer: `
+    @keyframes shimmer {
+      from {
+        left: -120%;
+      }
+      to {
+        left: 100%;
+      }
+    }
+  `
 };
 
 exports.Animation = Animation;
+exports.Keyframes = Keyframes;

package/dist/cjs/styles/token/color.js

@@ -190,6 +190,30 @@ const Color = {
       "yellow-8": "#926102",
       "yellow-9": "#6B4803",
       "yellow-10": "#483100"
+    },
+    pink: {
+      "pink-1": "#FED1FE",
+      "pink-2": "#FDBCFD",
+      "pink-3": "#F99BF8",
+      "pink-4": "#F573F2",
+      "pink-5": "#ED5BE5",
+      "pink-6": "#E136C6",
+      "pink-7": "#CF23A9",
+      "pink-8": "#B5158D",
+      "pink-9": "#910B6E",
+      "pink-10": "#64054B"
+    },
+    cyan: {
+      "cyan-1": "#A0ECEC",
+      "cyan-2": "#83E2E3",
+      "cyan-3": "#67D8D9",
+      "cyan-4": "#3AC4C6",
+      "cyan-5": "#1AACB4",
+      "cyan-6": "#048BA1",
+      "cyan-7": "#00728E",
+      "cyan-8": "#00607B",
+      "cyan-9": "#005068",
+      "cyan-10": "#004155"
     }
   },
   white: {

package/dist/cjs/utils/constants.js

@@ -1,15 +1,19 @@
 'use strict';
 
+var iconsReact = require('@cloudtower/icons-react');
+var React = require('react');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
 const EMPTY_FUNCTION = () => {
 };
 const Antd5PrefixCls = "antd5";
-const Antd5ComponentPrefixCls = {
-  Cascader: `${Antd5PrefixCls}-cascader`,
-  Progress: `${Antd5PrefixCls}-progress`,
-  Segmented: `${Antd5PrefixCls}-segmented`,
-  Menu: `${Antd5PrefixCls}-menu`
+const splitMap = {
+  dot: /* @__PURE__ */ React__default.default.createElement(iconsReact.DotIntervalSeparation16TertiaryIcon, null)
 };
 
-exports.Antd5ComponentPrefixCls = Antd5ComponentPrefixCls;
 exports.Antd5PrefixCls = Antd5PrefixCls;
 exports.EMPTY_FUNCTION = EMPTY_FUNCTION;
+exports.splitMap = splitMap;

package/dist/cjs/utils/cterror.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var _ = require('lodash');
+
+const isResponseCTError = (error) => {
+  return typeof error === "object" && error !== null && ("code" in error || "message" in error || "details" in error);
+};
+const handleResponseCTError = (error) => {
+  var _a;
+  if ("details" in error && ((_a = error.details) == null ? void 0 : _a.length)) {
+    return error.details.map((detail) => ({
+      code: detail.reason,
+      message: detail.message,
+      params: detail.params
+    }));
+  } else if ("code" in error) {
+    const code = error.code;
+    if (!_.isNil(code)) {
+      return [{ code, params: error.params }];
+    }
+  }
+  if ("message" in error && typeof error.message === "string") {
+    return [{ message: error.message }];
+  }
+  return [{ message: String(error) }];
+};
+const isAxiosCTError = (error) => {
+  return typeof error === "object" && error !== null && "isAxiosError" in error && error.isAxiosError === true;
+};
+const handleAxiosCTError = (error) => {
+  var _a;
+  if ((_a = error.response) == null ? void 0 : _a.data) {
+    const responseData = error.response.data;
+    if (responseData && typeof responseData === "object") {
+      const respError = handleResponseCTError(responseData);
+      if (respError.length) {
+        return respError;
+      }
+    }
+  }
+  return [{ code: `AXIOS_${error.code}` }];
+};
+const parseCTError = (error) => {
+  if (typeof error === "object" && error !== null) {
+    if (isAxiosCTError(error)) {
+      return handleAxiosCTError(error);
+    }
+    if (isResponseCTError(error)) {
+      return handleResponseCTError(error);
+    }
+    try {
+      return [{ message: JSON.stringify(error) }];
+    } catch (e) {
+      return [{ message: String(error) }];
+    }
+  }
+  return [{ message: String(error) }];
+};
+
+exports.handleAxiosCTError = handleAxiosCTError;
+exports.handleResponseCTError = handleResponseCTError;
+exports.isAxiosCTError = isAxiosCTError;
+exports.isResponseCTError = isResponseCTError;
+exports.parseCTError = parseCTError;

package/dist/cjs/utils/formatDuration.js

@@ -0,0 +1,67 @@
+'use strict';
+
+function formatDuration(milliseconds, options = {}) {
+  const { maxDisplayUnits = 2, minUnit = "second" } = options;
+  const effectiveMaxDisplayUnits = Math.max(1, maxDisplayUnits);
+  if (milliseconds < 0 || milliseconds === 0) {
+    const minUnitValue2 = minUnit || "second";
+    return [{ value: 0, unit: minUnitValue2 }];
+  }
+  const units = [
+    { value: 365 * 24 * 60 * 60 * 1e3, unit: "year" },
+    { value: 30 * 24 * 60 * 60 * 1e3, unit: "month" },
+    { value: 7 * 24 * 60 * 60 * 1e3, unit: "week" },
+    { value: 24 * 60 * 60 * 1e3, unit: "day" },
+    { value: 60 * 60 * 1e3, unit: "hour" },
+    { value: 60 * 1e3, unit: "minute" },
+    { value: 1e3, unit: "second" },
+    { value: 1, unit: "millisecond" }
+  ];
+  const minUnitValue = minUnit || "second";
+  const minUnitIndex = units.findIndex((u) => u.unit === minUnitValue);
+  if (minUnitIndex === -1) {
+    const defaultMinUnitIndex = units.findIndex((u) => u.unit === "second");
+    const filteredUnits2 = units.slice(0, defaultMinUnitIndex + 1);
+    const parts2 = [];
+    let remaining2 = milliseconds;
+    for (const unitDef of filteredUnits2) {
+      if (remaining2 >= unitDef.value) {
+        const count = Math.floor(remaining2 / unitDef.value);
+        remaining2 = remaining2 % unitDef.value;
+        parts2.push({
+          value: count,
+          unit: unitDef.unit
+        });
+        if (parts2.length >= effectiveMaxDisplayUnits) {
+          break;
+        }
+      }
+    }
+    if (parts2.length === 0) {
+      return [{ value: 0, unit: "second" }];
+    }
+    return parts2;
+  }
+  const filteredUnits = units.slice(0, minUnitIndex + 1);
+  const parts = [];
+  let remaining = milliseconds;
+  for (const unitDef of filteredUnits) {
+    if (remaining >= unitDef.value) {
+      const count = Math.floor(remaining / unitDef.value);
+      remaining = remaining % unitDef.value;
+      parts.push({
+        value: count,
+        unit: unitDef.unit
+      });
+      if (parts.length >= effectiveMaxDisplayUnits) {
+        break;
+      }
+    }
+  }
+  if (parts.length === 0) {
+    return [{ value: 0, unit: minUnitValue || "second" }];
+  }
+  return parts;
+}
+
+exports.formatDuration = formatDuration;

package/dist/cjs/utils/tower.js

@@ -125,6 +125,22 @@ function formatBytes(bytes, decimals = 2) {
     unit: units[i]
   };
 }
+function formatBytePerSecond(bytes, decimals = 2) {
+  if (bytes <= 0 || bytes === MAGIC_METRIC_NULL) {
+    return {
+      value: 0,
+      unit: "B/s"
+    };
+  }
+  const k = 1024;
+  const units = ["B/s", "KiB/s", "MiB/s", "GiB/s", "TiB/s", "PiB/s"];
+  let i = Math.floor(Math.log(bytes) / Math.log(k));
+  i = i < 0 ? 0 : i > units.length - 1 ? units.length - 1 : i;
+  return {
+    value: parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)),
+    unit: units[i]
+  };
+}
 function formatPercent(input, decimals = 2, saturated = true) {
   if (input === MAGIC_METRIC_NULL) {
     input = 0;
@@ -171,9 +187,86 @@ function formatSpeed(input, decimals = 0) {
     unit: units[i]
   };
 }
+const K = 1e3;
+function formatCount(input) {
+  if (input === MAGIC_METRIC_NULL) {
+    input = 0;
+  }
+  const units = ["", "K", "M", "G", "T", "P"];
+  let i = Math.floor(Math.log(input || 1) / Math.log(K));
+  i = i < 0 ? 0 : i > units.length - 1 ? units.length - 1 : i;
+  return {
+    value: parseFloat((input / Math.pow(K, i)).toFixed(2)),
+    unit: units[i]
+  };
+}
+function formatNanoSecond(input) {
+  if (input <= 0 || input === MAGIC_METRIC_NULL) {
+    return {
+      value: 0,
+      unit: ""
+    };
+  }
+  const units = ["ns", "\u03BCs", "ms", "s", "min", "h", "day"];
+  const divider = [1e3, 1e3, 1e3, 60, 60, 24];
+  let multiplier = 1;
+  for (let i = 0; i < divider.length; i++) {
+    if (input < multiplier * divider[i]) {
+      return {
+        value: parseFloat((input / multiplier).toFixed(2)),
+        unit: units[i]
+      };
+    }
+    multiplier *= divider[i];
+  }
+  return {
+    value: parseFloat((input / multiplier).toFixed(2)),
+    unit: "day"
+  };
+}
+function formatTemperature(input, decimals = 2) {
+  if (input === MAGIC_METRIC_NULL) {
+    input = 0;
+  }
+  return {
+    value: parseFloat(input.toFixed(decimals)),
+    unit: "\u2103"
+  };
+}
+const unitRules = [
+  {
+    divider: [1e3, 1e3, 1e3, 1e3, 1e3, 1e3],
+    unit: ["", "K", "M", "G", "T", "P"]
+  },
+  {
+    divider: [1e3, 1e3, 1e3, 1e3, 1e3, 1e3],
+    unit: ["bps", "Kbps", "Mbps", "Gbps", "Tbps", "Pbps"]
+  },
+  {
+    divider: [1e3, 1e3, 1e3, 1e3, 1e3, 1e3],
+    unit: ["Bps", "KBps", "MBps", "GBps", "TBps", "PBps"]
+  },
+  {
+    divider: [1024, 1024, 1024, 1024, 1024, 1024],
+    unit: ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
+  },
+  {
+    divider: [1024, 1024, 1024, 1024, 1024, 1024],
+    unit: ["B/s", "KiB/s", "MiB/s", "GiB/s", "TiB/s", "PiB/s"]
+  },
+  {
+    divider: [1e3, 1e3, 1e3, 60, 60, 24],
+    unit: ["ns", "\u03BCs", "ms", "s", "min", "h"]
+  },
+  {
+    divider: [1e3, 1e3, 1e3, 1e3, 1e3],
+    unit: ["Hz", "KHz", "MHz", "GHz", "THz"]
+  }
+];
 
 exports.DAY = DAY;
 exports.HOUR = HOUR;
+exports.K = K;
 exports.MAGIC_METRIC_NULL = MAGIC_METRIC_NULL;
 exports.MINUTE = MINUTE;
 exports.SECOND = SECOND;
@@ -181,8 +274,13 @@ exports.WEEK = WEEK;
 exports.formatBitPerSecond = formatBitPerSecond;
 exports.formatBits = formatBits;
 exports.formatBps = formatBps;
+exports.formatBytePerSecond = formatBytePerSecond;
 exports.formatBytes = formatBytes;
+exports.formatCount = formatCount;
 exports.formatFrequency = formatFrequency;
+exports.formatNanoSecond = formatNanoSecond;
 exports.formatPercent = formatPercent;
 exports.formatSeconds = formatSeconds;
 exports.formatSpeed = formatSpeed;
+exports.formatTemperature = formatTemperature;
+exports.unitRules = unitRules;

package/dist/cjs/utils/unit.js

@@ -0,0 +1,19 @@
+'use strict';
+
+function parseNumberAndUnit(str) {
+  if (typeof str !== "string") {
+    return null;
+  }
+  const match = str.trim().match(/^([+-]?\d*\.?\d+)(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const number = parseFloat(match[1]);
+  const unit = match[2].trim();
+  if (isNaN(number)) {
+    return null;
+  }
+  return { number, unit };
+}
+
+exports.parseNumberAndUnit = parseNumberAndUnit;