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

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

@@ -44921,11 +44921,6 @@
     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;
@@ -44966,30 +44961,67 @@
         /* @__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
@@ -44997,19 +45029,203 @@
       );
       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 });
   };
 
@@ -46648,6 +46864,7 @@ if (_IS_WORKLET) registerPaint("spoiler", SpoilerPainterWorklet);
     Tolerations,
     Annotations,
     ConverterBytes,
+    ConverterCores,
     SecretBase64Plain,
     ResourceBadge,
     Events: Events$1,