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

package/dist/esm/store/modal.js

@@ -22,6 +22,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 = {
@@ -55,6 +56,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/esm/styles/token/animation.js

@@ -1,5 +1,25 @@
 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%;
+      }
+    }
+  `
 };
 
-export { Animation };
+export { Animation, Keyframes };

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

@@ -188,6 +188,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/esm/utils/constants.js

@@ -1,11 +1,11 @@
+import { DotIntervalSeparation16TertiaryIcon } from '@cloudtower/icons-react';
+import React__default from '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.createElement(DotIntervalSeparation16TertiaryIcon, null)
 };
 
-export { Antd5ComponentPrefixCls, Antd5PrefixCls, EMPTY_FUNCTION };
+export { Antd5PrefixCls, EMPTY_FUNCTION, splitMap };

package/dist/esm/utils/cterror.js

@@ -0,0 +1,58 @@
+import { isNil } from '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) }];
+};
+
+export { handleAxiosCTError, handleResponseCTError, isAxiosCTError, isResponseCTError, parseCTError };

package/dist/esm/utils/formatDuration.js

@@ -0,0 +1,65 @@
+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;
+}
+
+export { formatDuration };

package/dist/esm/utils/tower.js

@@ -123,6 +123,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;
@@ -169,5 +185,81 @@ 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"]
+  }
+];
 
-export { DAY, HOUR, MAGIC_METRIC_NULL, MINUTE, SECOND, WEEK, formatBitPerSecond, formatBits, formatBps, formatBytes, formatFrequency, formatPercent, formatSeconds, formatSpeed };
+export { DAY, HOUR, K, MAGIC_METRIC_NULL, MINUTE, SECOND, WEEK, formatBitPerSecond, formatBits, formatBps, formatBytePerSecond, formatBytes, formatCount, formatFrequency, formatNanoSecond, formatPercent, formatSeconds, formatSpeed, formatTemperature, unitRules };

package/dist/esm/utils/unit.js

@@ -0,0 +1,17 @@
+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 };
+}
+
+export { parseNumberAndUnit };