@prorobotech/openapi-k8s-toolkit 1.2.0-alpha.3 → 1.2.0-alpha.4

package/dist/openapi-k8s-toolkit.es.js

@@ -44922,11 +44922,6 @@ const toBytes = (value, from) => {
   const factor = UNIT_FACTORS[canon];
   return value * factor;
 };
-const convertStorage = (value, from, to, opts) => {
-  const bytes = toBytes(value, from);
-  if (bytes < 0) return -1;
-  return convertBytes(bytes, to, opts);
-};
 const parseValueWithUnit = (input) => {
   const trimmed = input.trim();
   if (!trimmed) return null;
@@ -44967,30 +44962,67 @@ const ConverterBytes = ({ data }) => {
       /* @__PURE__ */ jsxRuntimeExports.jsx("ul", { children: errors.map((e, i) => e && /* @__PURE__ */ jsxRuntimeExports.jsx("li", { children: typeof e === "string" ? e : e.message }, i)) })
     ] });
   }
-  const replaceValues = partsOfUrl.partsOfUrl.reduce((acc, value2, index) => {
-    acc[index.toString()] = value2;
+  const replaceValues = partsOfUrl.partsOfUrl.reduce((acc, value, index) => {
+    acc[index.toString()] = value;
     return acc;
   }, {});
-  const parsedBytesValue = parseAll({ text: bytesValue, replaceValues, multiQueryData });
-  const parsedWithUnit = parseValueWithUnit(parsedBytesValue);
-  if (!parsedWithUnit) {
-    const fallbackNumber = Number(parsedBytesValue);
-    if (Number.isNaN(fallbackNumber)) {
-      return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
-    }
-    if (unit) {
-      const result3 = String(convertBytes(fallbackNumber, unit, { format, precision, locale }));
+  const byteValueItems = Array.isArray(bytesValue) ? bytesValue : [bytesValue];
+  const resolvedStrings = byteValueItems.map((text) => parseAll({ text, replaceValues, multiQueryData }));
+  if (resolvedStrings.length === 0) {
+    const targetUnit2 = toUnit || unit;
+    if (targetUnit2) {
+      const result3 = String(
+        convertBytes(0, targetUnit2, {
+          format,
+          precision,
+          locale
+        })
+      );
       return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result3 });
     }
-    const result2 = formatBytesAuto(fallbackNumber, { standard, precision, locale });
+    const result2 = formatBytesAuto(0, { standard, precision, locale });
     return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result2 });
   }
-  const { value, unit: inlineUnit } = parsedWithUnit;
-  const effectiveFromUnit = fromUnit || inlineUnit;
+  let totalBytes = 0;
+  for (const s of resolvedStrings) {
+    const parsed = parseValueWithUnit(s);
+    let numericValue;
+    let inlineUnit;
+    if (parsed) {
+      numericValue = parsed.value;
+      inlineUnit = parsed.unit;
+    } else {
+      const fallbackNumber = Number(s);
+      if (Number.isNaN(fallbackNumber)) {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+      numericValue = fallbackNumber;
+      inlineUnit = void 0;
+    }
+    const fromForThis = fromUnit || inlineUnit || "B";
+    let bytesForThis;
+    if (fromForThis === "B") {
+      if (!Number.isFinite(numericValue)) {
+        console.error("bytes must be a finite number");
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+      if (numericValue < 0) {
+        console.error("bytes must be >= 0");
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+      bytesForThis = numericValue;
+    } else {
+      bytesForThis = toBytes(numericValue, fromForThis);
+      if (bytesForThis < 0) {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+    }
+    totalBytes += bytesForThis;
+  }
   const targetUnit = toUnit || unit;
-  if (effectiveFromUnit && targetUnit) {
+  if (targetUnit) {
     const result2 = String(
-      convertStorage(value, effectiveFromUnit, targetUnit, {
+      convertBytes(totalBytes, targetUnit, {
         format,
         precision,
         locale
@@ -44998,19 +45030,203 @@ const ConverterBytes = ({ data }) => {
     );
     return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result2 });
   }
-  if (effectiveFromUnit && !targetUnit) {
-    const bytes = toBytes(value, effectiveFromUnit);
-    if (bytes < 0) {
-      return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+  const result = formatBytesAuto(totalBytes, { standard, precision, locale });
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result });
+};
+
+const CORE_UNIT_FACTORS = {
+  core: 1,
+  mcore: 1e-3,
+  ucore: 1e-6,
+  ncore: 1e-9
+};
+const CORE_ALIASES = (() => {
+  const corePairs = [
+    // plain cores
+    [["core", "cores", "c", "cpu", "cpus", "vcpu", "vcpus"], "core"],
+    // millicores
+    [["m", "mc", "mcore", "mcores", "millicore", "millicores", "millicpu", "millicpus"], "mcore"],
+    // microcores
+    [["u", "µ", "ucore", "ucores", "micro", "microcore", "microcores"], "ucore"],
+    // nanocores
+    [["n", "ncore", "ncores", "nano", "nanocore", "nanocores"], "ncore"]
+  ];
+  const entries = corePairs.flatMap(([keys, unit]) => keys.map((k) => [k.toLowerCase(), unit]));
+  const canon = Object.keys(CORE_UNIT_FACTORS).map((u) => [u.toLowerCase(), u]);
+  return Object.fromEntries([...entries, ...canon]);
+})();
+const normalizeCoreUnit = (u) => {
+  const key = String(u).trim().toLowerCase();
+  const canon = CORE_ALIASES[key];
+  if (!canon) {
+    console.error(`Unknown core unit: "${u}"`);
+    return "core";
+  }
+  return canon;
+};
+const convertCores = (cores, unit, opts) => {
+  if (!Number.isFinite(cores)) {
+    console.error("cores must be a finite number");
+    return -1;
+  }
+  if (cores < 0) {
+    console.error("cores must be >= 0");
+    return -1;
+  }
+  const canon = normalizeCoreUnit(unit);
+  const factor = CORE_UNIT_FACTORS[canon];
+  const value = cores / factor;
+  if (!opts?.format) return value;
+  return `${value.toLocaleString(opts.locale, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: opts?.precision ?? 2
+  })} ${canon}`;
+};
+const formatCoresAuto = (cores, { precision = 2, locale } = {}) => {
+  if (!Number.isFinite(cores)) {
+    console.error("cores must be a finite number");
+    return "infinite";
+  }
+  if (cores < 0) {
+    console.error("cores must be >= 0");
+    return "less then zero";
+  }
+  if (cores === 0) {
+    return "0 core";
+  }
+  let targetUnit;
+  if (cores >= 1) {
+    targetUnit = "core";
+  } else if (cores >= 1e-3) {
+    targetUnit = "mcore";
+  } else if (cores >= 1e-6) {
+    targetUnit = "ucore";
+  } else {
+    targetUnit = "ncore";
+  }
+  return String(convertCores(cores, targetUnit, { format: true, precision, locale }));
+};
+const toCores = (value, from) => {
+  if (!Number.isFinite(value)) {
+    console.error("value must be a finite number");
+    return -1;
+  }
+  if (value < 0) {
+    console.error("value must be >= 0");
+    return -1;
+  }
+  const canon = normalizeCoreUnit(from);
+  const factor = CORE_UNIT_FACTORS[canon];
+  return value * factor;
+};
+const parseCoresWithUnit = (input) => {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const match = trimmed.match(/^([+-]?\d+(?:\.\d+)?)(?:\s*([a-zA-Zµ]+))?$/);
+  if (!match) return null;
+  const [, numPart, unitPart] = match;
+  const value = Number(numPart);
+  if (!Number.isFinite(value)) return null;
+  if (unitPart) {
+    return { value, unit: unitPart };
+  }
+  return { value };
+};
+
+const ConverterCores = ({ data }) => {
+  const {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    id,
+    coresValue,
+    unit,
+    fromUnit,
+    toUnit,
+    format,
+    precision,
+    locale,
+    notANumberText,
+    style
+  } = data;
+  const { data: multiQueryData, isLoading, isError, errors } = useMultiQuery();
+  const partsOfUrl = usePartsOfUrl();
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: "Loading..." });
+  }
+  if (isError) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("h4", { children: "Errors:" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("ul", { children: errors.map((e, i) => e && /* @__PURE__ */ jsxRuntimeExports.jsx("li", { children: typeof e === "string" ? e : e.message }, i)) })
+    ] });
+  }
+  const replaceValues = partsOfUrl.partsOfUrl.reduce((acc, value, index) => {
+    acc[index.toString()] = value;
+    return acc;
+  }, {});
+  const coreValueItems = Array.isArray(coresValue) ? coresValue : [coresValue];
+  const resolvedStrings = coreValueItems.map((text) => parseAll({ text, replaceValues, multiQueryData }));
+  if (resolvedStrings.length === 0) {
+    const targetUnit2 = toUnit || unit;
+    if (targetUnit2) {
+      const result3 = String(
+        convertCores(0, targetUnit2, {
+          format,
+          precision,
+          locale
+        })
+      );
+      return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result3 });
     }
-    const result2 = formatBytesAuto(bytes, { standard, precision, locale });
+    const result2 = formatCoresAuto(0, { precision, locale });
     return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result2 });
   }
+  let totalCores = 0;
+  for (const s of resolvedStrings) {
+    const parsed = parseCoresWithUnit(s);
+    let numericValue;
+    let inlineUnit;
+    if (parsed) {
+      numericValue = parsed.value;
+      inlineUnit = parsed.unit;
+    } else {
+      const fallbackNumber = Number(s);
+      if (Number.isNaN(fallbackNumber)) {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+      numericValue = fallbackNumber;
+      inlineUnit = void 0;
+    }
+    const fromForThis = fromUnit || inlineUnit || "core";
+    let coresForThis;
+    if (fromForThis === "core") {
+      if (!Number.isFinite(numericValue)) {
+        console.error("cores must be a finite number");
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+      if (numericValue < 0) {
+        console.error("cores must be >= 0");
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+      coresForThis = numericValue;
+    } else {
+      coresForThis = toCores(numericValue, fromForThis);
+      if (coresForThis < 0) {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: notANumberText || "Not a proper value" });
+      }
+    }
+    totalCores += coresForThis;
+  }
+  const targetUnit = toUnit || unit;
   if (targetUnit) {
-    const result2 = String(convertBytes(value, targetUnit, { format, precision, locale }));
+    const result2 = String(
+      convertCores(totalCores, targetUnit, {
+        format,
+        precision,
+        locale
+      })
+    );
     return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result2 });
   }
-  const result = formatBytesAuto(value, { standard, precision, locale });
+  const result = formatCoresAuto(totalCores, { precision, locale });
   return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style, children: result });
 };
 
@@ -46649,6 +46865,7 @@ const DynamicComponents = {
   Tolerations,
   Annotations,
   ConverterBytes,
+  ConverterCores,
   SecretBase64Plain,
   ResourceBadge,
   Events: Events$1,