@cloudtower/eagle 0.0.0-no-uikit-1 → 0.0.0-theme-rc-1

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

@@ -0,0 +1,43 @@
+'use strict';
+
+const Effect = {
+  "shadow": {
+    "dashboardCard": {
+      "normal": "var(--effect-shadow-dashboardCard-normal)",
+      "hoverFloat": "var(--effect-shadow-dashboardCard-hoverFloat)"
+    },
+    "listItem": {
+      "hover": "var(--effect-shadow-listItem-hover)",
+      "selected": "var(--effect-shadow-listItem-selected)"
+    },
+    "menu": {
+      "default": "var(--effect-shadow-menu-default)",
+      "above": "var(--effect-shadow-menu-above)"
+    },
+    "button": {
+      "cta": "var(--effect-shadow-button-cta)",
+      "ordinary": "var(--effect-shadow-button-ordinary)"
+    },
+    "previewPanel": {
+      "default": "var(--effect-shadow-previewPanel-default)",
+      "above": "var(--effect-shadow-previewPanel-above)"
+    },
+    "tooltip": "var(--effect-shadow-tooltip)"
+  },
+  "glow": {
+    "toast": {
+      "blue": "var(--effect-glow-toast-blue)",
+      "red": "var(--effect-glow-toast-red)",
+      "green": "var(--effect-glow-toast-green)",
+      "yellow": "var(--effect-glow-toast-yellow)"
+    }
+  },
+  "outline": {
+    "hover": "var(--effect-outline-hover)",
+    "activeFocus": "var(--effect-outline-activeFocus)",
+    "error": "var(--effect-outline-error)",
+    "notice": "var(--effect-outline-notice)"
+  }
+};
+
+exports.Effect = Effect;

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

@@ -0,0 +1,18 @@
+'use strict';
+
+const resolveColorValue = (color, element) => {
+  var _a;
+  const name = (_a = /^var\((--[\w-]+)\)$/.exec(color)) == null ? void 0 : _a[1];
+  if (!name || typeof document === "undefined") {
+    throw new Error(`Cannot resolve theme color: ${color}`);
+  }
+  const value = getComputedStyle(element != null ? element : document.documentElement).getPropertyValue(name).trim();
+  if (!value || value.includes("var(")) {
+    throw new Error(
+      `Missing theme color ${name}; load Eagle token.css before rendering`
+    );
+  }
+  return value;
+};
+
+exports.resolveColorValue = resolveColorValue;

package/dist/cjs/utils/constants.js

@@ -1,8 +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 splitMap = {
+  dot: /* @__PURE__ */ React__default.default.createElement(iconsReact.DotIntervalSeparation16TertiaryIcon, null)
+};
 
 exports.Antd5PrefixCls = Antd5PrefixCls;
 exports.EMPTY_FUNCTION = EMPTY_FUNCTION;
+exports.splitMap = splitMap;

package/dist/cjs/utils/cterror.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var _ = require('lodash');
+
+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 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)) {
+    const validDetails = error.details.filter(
+      (detail) => !_.isNil(detail.reason) && detail.reason !== ""
+    );
+    if (validDetails.length) {
+      return validDetails.map((detail) => __spreadValues(__spreadValues({
+        code: detail.reason
+      }, !_.isNil(detail.message) ? { message: detail.message } : {}), !_.isNil(detail.params) ? { params: detail.params } : {}));
+    }
+    return [
+      __spreadValues({}, !_.isNil(error.code) ? { code: error.code } : {})
+    ];
+  } 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;