@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/esm2022/utils/tree.mjs

@@ -0,0 +1,79 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+// reduceTree :: String -> (a -> Tree -> [Tree] -> [Number] -> a) -> a -> [Tree] -> a
+export const reduceTrees = (subtreeKey) => (fn) => (seed) => (trees) => {
+    const reducer = (nodes, parents, path, acc) => nodes.reduce((prev, curr, index) => {
+        const result = fn(prev, curr, parents, [...path, index]);
+        return curr[subtreeKey]
+            ? reducer(curr[subtreeKey], [...parents, curr], [...path, index], result)
+            : result;
+    }, acc);
+    return reducer(trees, [], [], seed);
+};
+// mapTree :: String -> (Tree -> [Tree] -> [Number] -> Tree) -> [Tree] -> [Tree]
+export const mapTrees = (subtreeKey) => (fn) => (trees) => {
+    const mapper = (acc, curr, parents, path) => {
+        const mapped = fn(curr, parents, path);
+        return setNode(subtreeKey, path, acc, mapped);
+    };
+    return reduceTrees(subtreeKey)(mapper)([])(trees);
+};
+export const filterTrees = (subtreeKey) => (fn) => (trees) => {
+    const filter = (nodes, parents, path) => nodes
+        ?.filter(node => fn(node, parents, path))
+        .map((node, index) => node[subtreeKey]
+        ? {
+            ...node,
+            [subtreeKey]: filter(node[subtreeKey], [...parents, node], [...path, index]),
+        }
+        : node);
+    return filter(trees, [], []);
+};
+export const findPath = (subtreeKey) => (fn) => (trees) => {
+    const endPoint = [];
+    const finder = (nodes, parents, path) => {
+        const result = nodes.find((node, index) => {
+            if (fn(node, parents, path)) {
+                return true;
+            }
+            if (node[subtreeKey]) {
+                return finder(node[subtreeKey], [...parents, node], [...path, index]);
+            }
+            return false;
+        });
+        if (result) {
+            endPoint.unshift(result);
+        }
+        return !!result;
+    };
+    finder(trees, [], []);
+    return endPoint;
+};
+export const firstPath = (subtreeKey) => (trees) => {
+    const head = trees[0];
+    if (head) {
+        return head.children
+            ? [head, ...firstPath(subtreeKey)(head[subtreeKey])]
+            : [head];
+    }
+    return [];
+};
+export function setNode(subtreeKey, path, source, target) {
+    const iterator = ([head, ...tail], trees) => {
+        if (tail.length > 0) {
+            const point = trees[head] || {};
+            const tree = {
+                ...point,
+                [subtreeKey]: iterator(tail, (point[subtreeKey] || [])),
+            };
+            trees[head] = tree;
+            return trees;
+        }
+        trees[head] = target;
+        return trees;
+    };
+    return iterator(path, source);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/utils/tree.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\n// reduceTree :: String -> (a -> Tree -> [Tree] -> [Number] -> a) -> a -> [Tree] -> a\nexport const reduceTrees =\n  (subtreeKey: string) =>\n  <T extends Tree, R>(fn: TreeReducer<T, R>) =>\n  (seed: R) =>\n  (trees: T[]) => {\n    const reducer = (nodes: T[], parents: T[], path: number[], acc: R): R =>\n      nodes.reduce((prev, curr, index) => {\n        const result = fn(prev, curr, parents, [...path, index]);\n        return curr[subtreeKey]\n          ? reducer(\n              curr[subtreeKey] as T[],\n              [...parents, curr],\n              [...path, index],\n              result,\n            )\n          : result;\n      }, acc);\n    return reducer(trees, [], [], seed);\n  };\n\n// mapTree :: String -> (Tree -> [Tree] -> [Number] -> Tree) -> [Tree] -> [Tree]\nexport const mapTrees =\n  (subtreeKey: string) =>\n  <T extends Tree, R extends Tree>(fn: TreeMapper<T, R>) =>\n  (trees: T[]) => {\n    const mapper = (acc: R[], curr: T, parents: T[], path: number[]) => {\n      const mapped = fn(curr, parents, path);\n      return setNode<R>(subtreeKey, path, acc, mapped);\n    };\n    return reduceTrees(subtreeKey)<T, R[]>(mapper)([])(trees);\n  };\n\nexport const filterTrees =\n  (subtreeKey: string) =>\n  <T extends Tree>(fn: TreeFilter<T>) =>\n  (trees: T[]) => {\n    const filter = (nodes: T[], parents: T[], path: number[]): T[] =>\n      nodes\n        ?.filter(node => fn(node, parents, path))\n        .map((node, index) =>\n          node[subtreeKey]\n            ? {\n                ...node,\n                [subtreeKey]: filter(\n                  node[subtreeKey] as T[],\n                  [...parents, node],\n                  [...path, index],\n                ),\n              }\n            : node,\n        );\n    return filter(trees, [], []);\n  };\n\nexport const findPath =\n  (subtreeKey: string) =>\n  <T extends Tree>(fn: TreeFilter<T>) =>\n  (trees: T[]) => {\n    const endPoint: T[] = [];\n    const finder = (nodes: T[], parents: T[], path: number[]): boolean => {\n      const result = nodes.find((node, index) => {\n        if (fn(node, parents, path)) {\n          return true;\n        }\n        if (node[subtreeKey]) {\n          return finder(\n            node[subtreeKey] as T[],\n            [...parents, node],\n            [...path, index],\n          );\n        }\n        return false;\n      });\n      if (result) {\n        endPoint.unshift(result);\n      }\n      return !!result;\n    };\n\n    finder(trees, [], []);\n    return endPoint;\n  };\n\nexport const firstPath =\n  (subtreeKey: string) =>\n  <T extends Tree>(trees: T[]): T[] => {\n    const head = trees[0];\n    if (head) {\n      return head.children\n        ? [head, ...firstPath(subtreeKey)<T>(head[subtreeKey] as T[])]\n        : [head];\n    }\n    return [];\n  };\n\nexport function setNode<T extends Tree>(\n  subtreeKey: string,\n  path: number[],\n  source: T[],\n  target: T,\n) {\n  const iterator = ([head, ...tail]: number[], trees: T[]) => {\n    if (tail.length > 0) {\n      const point = trees[head] || ({} as T);\n      const tree = {\n        ...point,\n        [subtreeKey]: iterator(tail, (point[subtreeKey] || []) as T[]),\n      };\n      trees[head] = tree;\n      return trees;\n    }\n    trees[head] = target;\n    return trees;\n  };\n  return iterator(path, source);\n}\n\nexport interface Tree {\n  [key: string]: Tree[];\n}\n\nexport type TreeReducer<T extends Tree, R> = (\n  acc: R,\n  currentNode: T,\n  parents: T[],\n  path: number[],\n) => R;\n\nexport type TreeMapper<T extends Tree, R extends Tree> = (\n  tree: T,\n  parents: T[],\n  path: number[],\n) => R;\n\nexport type TreeFilter<T extends Tree> = (\n  tree: T,\n  parents: T[],\n  path: number[],\n) => boolean;\n"]}

package/esm2022/utils/unit.mjs

@@ -0,0 +1,191 @@
+import { isBlank, numToStr } from './common';
+const COMMON_UNITS = ['M', 'G', 'T', 'P', 'E'];
+export const CORE_UNITS = ['m', '', 'k', ...COMMON_UNITS];
+export const CORE_UNIT_REG = new RegExp(`[${CORE_UNITS.join('')}]$`);
+const toUnitNumBase = (coreStr, isUnitM = false) => {
+    if (typeof coreStr === 'number') {
+        return numToStr(coreStr * Math.pow(1000, +isUnitM));
+    }
+    if (isBlank(coreStr)) {
+        return '';
+    }
+    coreStr = coreStr.trim();
+    const num = +coreStr.replace(CORE_UNIT_REG, '');
+    if (Number.isNaN(num)) {
+        return '';
+    }
+    if (num <= 0) {
+        return '0';
+    }
+    const lastChar = coreStr.at(-1);
+    let unitIndex = CORE_UNITS.indexOf(lastChar);
+    unitIndex = (unitIndex === -1 ? 0 : unitIndex - 1) + +isUnitM;
+    return numToStr(num * Math.pow(1000, unitIndex));
+};
+export const toUnitNumM = (coreStr) => toUnitNumBase(coreStr, true);
+export const toUnitNum = (coreStr) => toUnitNumBase(coreStr);
+export const UNITS = ['', 'K', ...COMMON_UNITS];
+export const UNIT_REG = new RegExp(`[${UNITS.join('')}]i?$`);
+// TODO: UNITS 临时被其他地方当成了枚举项使用，先临时添加MEMORY_UNITS来处理 toUnitI 中兼容 k、Ki 的问题
+const MEMORY_UNITS = ['', ['k', 'K'], ...COMMON_UNITS];
+const MEMORY_UNIT_REG = new RegExp(`[${MEMORY_UNITS.join('')}]i?$`);
+export const toUnitI = (str, negative = false) => {
+    if (typeof str === 'number') {
+        if (str <= 0 && !negative) {
+            return '0';
+        }
+        return numToStr(str);
+    }
+    if (isBlank(str)) {
+        return '';
+    }
+    str = str.trim();
+    const num = +str.replace(MEMORY_UNIT_REG, '');
+    if (Number.isNaN(num)) {
+        return '';
+    }
+    if (num <= 0 && !negative) {
+        return '0';
+    }
+    let base = 1000;
+    if (str.endsWith('i')) {
+        base = 1024;
+        str = str.replace(/i$/, '');
+    }
+    const lastChar = str.at(-1);
+    const unitIndex = MEMORY_UNITS.findIndex(unit => Array.isArray(unit) ? unit.includes(lastChar) : unit === lastChar);
+    return numToStr(num * Math.pow(base, unitIndex === -1 ? 0 : unitIndex));
+};
+export const toUnitMi = (str, negative) => {
+    const unitI = toUnitI(str, negative);
+    if (!unitI) {
+        return '';
+    }
+    return numToStr(+unitI / 1024 / 1024);
+};
+export const toUnitGi = (str, negative) => {
+    const unitI = toUnitI(str, negative);
+    if (!unitI) {
+        return '';
+    }
+    return numToStr(+unitI / 1024 / 1024 / 1024);
+};
+export const addUnitCoreM = (coreStr) => {
+    if (isBlank(coreStr)) {
+        return null;
+    }
+    return numToStr(+coreStr) + 'm';
+};
+export const addUnitMi = (miStr) => {
+    if (isBlank(miStr)) {
+        return null;
+    }
+    return numToStr(+miStr) + 'Mi';
+};
+export const addUnitGi = (giStr) => {
+    if (isBlank(giStr)) {
+        return null;
+    }
+    return numToStr(+giStr) + 'Gi';
+};
+const POWER_MEMORY_UNITS = ['Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei'];
+export function getAppropriateMemory(base) {
+    let unit = -1;
+    while (base >= 800 || unit >= POWER_MEMORY_UNITS.length - 1) {
+        base /= 1024;
+        unit++;
+    }
+    return {
+        value: base,
+        unit: POWER_MEMORY_UNITS[unit],
+    };
+}
+const reg = /^(\d?\.?\d+)(\w+)*$/;
+export const parseValueAndUnit = (str) => {
+    const [_, value, unit] = /^(\d?\.?\d+)(\w+)*$/.exec(str) || [];
+    return [value, unit];
+};
+export function formatMemory(mem) {
+    const base = parseFloat(mem);
+    const res = reg.exec(mem);
+    const unit = res?.[2];
+    return unit ? getMemory(base, unit) : base;
+}
+export function getMemory(base, unit) {
+    switch (unit) {
+        case 'm': {
+            return base * 1e-3;
+        }
+        case 'K': {
+            return base * 1e3;
+        }
+        case 'Ki': {
+            return base * 1024;
+        }
+        case 'M': {
+            return base * 1e6;
+        }
+        case 'Mi': {
+            return base * 1024 ** 2;
+        }
+        case 'G': {
+            return base * 1e9;
+        }
+        case 'Gi': {
+            return base * 1024 ** 3;
+        }
+        case 'T': {
+            return base * 1e12;
+        }
+        case 'Ti': {
+            return base * 1024 ** 4;
+        }
+        case 'P': {
+            return base * 1e15;
+        }
+        case 'Pi': {
+            return base * 1024 ** 5;
+        }
+        case 'E': {
+            return base * 1e18;
+        }
+        case 'Ei': {
+            return base * 1024 ** 6;
+        }
+        default: {
+            return base;
+        }
+    }
+}
+export function getCpu(base, unit) {
+    switch (unit) {
+        case 'm': {
+            return base;
+        }
+        case 'c': {
+            return base * 1e3;
+        }
+        case 'k': {
+            return base * 1e6;
+        }
+        case 'M': {
+            return base * 1e9;
+        }
+        case 'G': {
+            return base * 1e12;
+        }
+        case 'T': {
+            return base * 1e15;
+        }
+        default: {
+            return base * 1e3;
+        }
+    }
+}
+export function formatCPU(cpu) {
+    const base = parseFloat(cpu);
+    const res = reg.exec(cpu);
+    const unit = res?.[2];
+    return getCpu(base, unit);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unit.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/utils/unit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE7C,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAE/C,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,YAAY,CAAC,CAAC;AAE1D,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,MAAM,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;AAErE,MAAM,aAAa,GAAG,CAAC,OAAyB,EAAE,OAAO,GAAG,KAAK,EAAE,EAAE;IACnE,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,OAAO,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IACzB,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;IAChD,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;QACb,OAAO,GAAG,CAAC;IACb,CAAC;IACD,MAAM,QAAQ,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAChC,IAAI,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7C,SAAS,GAAG,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC;IAC9D,OAAO,QAAQ,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;AACnD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,OAAyB,EAAE,EAAE,CACtD,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAE/B,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,OAAyB,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AAE/E,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,YAAY,CAAC,CAAC;AAChD,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;AAE7D,wEAAwE;AACxE,MAAM,YAAY,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,YAAY,CAAC,CAAC;AACvD,MAAM,eAAe,GAAG,IAAI,MAAM,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;AAEpE,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,GAAqB,EAAE,QAAQ,GAAG,KAAK,EAAE,EAAE;IACjE,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC;QACb,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACjB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IACjB,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;IAC9C,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC1B,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,IAAI,GAAG,IAAI,CAAC;IAEhB,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACtB,IAAI,GAAG,IAAI,CAAC;QACZ,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,QAAQ,GAAG,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5B,MAAM,SAAS,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAC9C,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAClE,CAAC;IACF,OAAO,QAAQ,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;AAC1E,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAqB,EAAE,QAAkB,EAAE,EAAE;IACpE,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAqB,EAAE,QAAkB,EAAE,EAAE;IACpE,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;AAC/C,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,OAAyB,EAAE,EAAE;IACxD,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;AAClC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAuB,EAAE,EAAE;IACnD,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAuB,EAAE,EAAE;IACnD,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;AACjC,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAEhE,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;IACd,OAAO,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5D,IAAI,IAAI,IAAI,CAAC;QACb,IAAI,EAAE,CAAC;IACT,CAAC;IACD,OAAO;QACL,KAAK,EAAE,IAAI;QACX,IAAI,EAAE,kBAAkB,CAAC,IAAI,CAAC;KAC/B,CAAC;AACJ,CAAC;AAED,MAAM,GAAG,GAAG,qBAAqB,CAAC;AAElC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,GAAW,EAAE,EAAE;IAC/C,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IAC/D,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACvB,CAAC,CAAC;AAEF,MAAM,UAAU,YAAY,CAAC,GAAW;IACtC,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1B,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,IAAY;IAClD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;QACD,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;QACD,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;QACD,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,OAAO,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,IAAY,EAAE,IAAY;IAC/C,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,CAAC;QACd,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,OAAO,IAAI,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,OAAO,IAAI,GAAG,GAAG,CAAC;QACpB,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,GAAW;IACnC,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1B,MAAM,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC5B,CAAC","sourcesContent":["import { isBlank, numToStr } from './common';\n\nconst COMMON_UNITS = ['M', 'G', 'T', 'P', 'E'];\n\nexport const CORE_UNITS = ['m', '', 'k', ...COMMON_UNITS];\n\nexport const CORE_UNIT_REG = new RegExp(`[${CORE_UNITS.join('')}]$`);\n\nconst toUnitNumBase = (coreStr?: string | number, isUnitM = false) => {\n  if (typeof coreStr === 'number') {\n    return numToStr(coreStr * Math.pow(1000, +isUnitM));\n  }\n\n  if (isBlank(coreStr)) {\n    return '';\n  }\n  coreStr = coreStr.trim();\n  const num = +coreStr.replace(CORE_UNIT_REG, '');\n  if (Number.isNaN(num)) {\n    return '';\n  }\n  if (num <= 0) {\n    return '0';\n  }\n  const lastChar = coreStr.at(-1);\n  let unitIndex = CORE_UNITS.indexOf(lastChar);\n  unitIndex = (unitIndex === -1 ? 0 : unitIndex - 1) + +isUnitM;\n  return numToStr(num * Math.pow(1000, unitIndex));\n};\n\nexport const toUnitNumM = (coreStr?: string | number) =>\n  toUnitNumBase(coreStr, true);\n\nexport const toUnitNum = (coreStr?: string | number) => toUnitNumBase(coreStr);\n\nexport const UNITS = ['', 'K', ...COMMON_UNITS];\nexport const UNIT_REG = new RegExp(`[${UNITS.join('')}]i?$`);\n\n// TODO: UNITS 临时被其他地方当成了枚举项使用，先临时添加MEMORY_UNITS来处理 toUnitI 中兼容 k、Ki 的问题\nconst MEMORY_UNITS = ['', ['k', 'K'], ...COMMON_UNITS];\nconst MEMORY_UNIT_REG = new RegExp(`[${MEMORY_UNITS.join('')}]i?$`);\n\nexport const toUnitI = (str?: string | number, negative = false) => {\n  if (typeof str === 'number') {\n    if (str <= 0 && !negative) {\n      return '0';\n    }\n    return numToStr(str);\n  }\n\n  if (isBlank(str)) {\n    return '';\n  }\n  str = str.trim();\n  const num = +str.replace(MEMORY_UNIT_REG, '');\n  if (Number.isNaN(num)) {\n    return '';\n  }\n  if (num <= 0 && !negative) {\n    return '0';\n  }\n\n  let base = 1000;\n\n  if (str.endsWith('i')) {\n    base = 1024;\n    str = str.replace(/i$/, '');\n  }\n\n  const lastChar = str.at(-1);\n  const unitIndex = MEMORY_UNITS.findIndex(unit =>\n    Array.isArray(unit) ? unit.includes(lastChar) : unit === lastChar,\n  );\n  return numToStr(num * Math.pow(base, unitIndex === -1 ? 0 : unitIndex));\n};\n\nexport const toUnitMi = (str?: string | number, negative?: boolean) => {\n  const unitI = toUnitI(str, negative);\n  if (!unitI) {\n    return '';\n  }\n  return numToStr(+unitI / 1024 / 1024);\n};\n\nexport const toUnitGi = (str?: string | number, negative?: boolean) => {\n  const unitI = toUnitI(str, negative);\n  if (!unitI) {\n    return '';\n  }\n  return numToStr(+unitI / 1024 / 1024 / 1024);\n};\n\nexport const addUnitCoreM = (coreStr?: string | number) => {\n  if (isBlank(coreStr)) {\n    return null;\n  }\n  return numToStr(+coreStr) + 'm';\n};\n\nexport const addUnitMi = (miStr?: string | number) => {\n  if (isBlank(miStr)) {\n    return null;\n  }\n  return numToStr(+miStr) + 'Mi';\n};\n\nexport const addUnitGi = (giStr?: string | number) => {\n  if (isBlank(giStr)) {\n    return null;\n  }\n  return numToStr(+giStr) + 'Gi';\n};\n\nconst POWER_MEMORY_UNITS = ['Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei'];\n\nexport function getAppropriateMemory(base: number) {\n  let unit = -1;\n  while (base >= 800 || unit >= POWER_MEMORY_UNITS.length - 1) {\n    base /= 1024;\n    unit++;\n  }\n  return {\n    value: base,\n    unit: POWER_MEMORY_UNITS[unit],\n  };\n}\n\nconst reg = /^(\\d?\\.?\\d+)(\\w+)*$/;\n\nexport const parseValueAndUnit = (str: string) => {\n  const [_, value, unit] = /^(\\d?\\.?\\d+)(\\w+)*$/.exec(str) || [];\n  return [value, unit];\n};\n\nexport function formatMemory(mem: string) {\n  const base = parseFloat(mem);\n  const res = reg.exec(mem);\n  const unit = res?.[2];\n  return unit ? getMemory(base, unit) : base;\n}\n\nexport function getMemory(base: number, unit: string) {\n  switch (unit) {\n    case 'm': {\n      return base * 1e-3;\n    }\n    case 'K': {\n      return base * 1e3;\n    }\n    case 'Ki': {\n      return base * 1024;\n    }\n    case 'M': {\n      return base * 1e6;\n    }\n    case 'Mi': {\n      return base * 1024 ** 2;\n    }\n    case 'G': {\n      return base * 1e9;\n    }\n    case 'Gi': {\n      return base * 1024 ** 3;\n    }\n    case 'T': {\n      return base * 1e12;\n    }\n    case 'Ti': {\n      return base * 1024 ** 4;\n    }\n    case 'P': {\n      return base * 1e15;\n    }\n    case 'Pi': {\n      return base * 1024 ** 5;\n    }\n    case 'E': {\n      return base * 1e18;\n    }\n    case 'Ei': {\n      return base * 1024 ** 6;\n    }\n    default: {\n      return base;\n    }\n  }\n}\n\nexport function getCpu(base: number, unit: string) {\n  switch (unit) {\n    case 'm': {\n      return base;\n    }\n    case 'c': {\n      return base * 1e3;\n    }\n    case 'k': {\n      return base * 1e6;\n    }\n    case 'M': {\n      return base * 1e9;\n    }\n    case 'G': {\n      return base * 1e12;\n    }\n    case 'T': {\n      return base * 1e15;\n    }\n    default: {\n      return base * 1e3;\n    }\n  }\n}\n\nexport function formatCPU(cpu: string) {\n  const base = parseFloat(cpu);\n  const res = reg.exec(cpu);\n  const unit = res?.[2];\n  return getCpu(base, unit);\n}\n"]}

package/esm2022/utils/version.mjs

@@ -0,0 +1,76 @@
+/**
+ * 基于相对严格的版本号规则，规范可以参考https://semver.org/
+ * 但在比较版本号时使用相对宽松的规则，具体可以查看compare-versions库的实现
+ * 自测用例：https://stackblitz.com/edit/typescript-jqszbj
+ */
+import { compare } from 'compare-versions';
+export { compareVersions as compareVersionToNum, satisfies as satisfiesVersion, } from 'compare-versions';
+export const versionRegex = /^(\d+)\.(\d+)\.(\d+)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?$/;
+const removeFirstV = (version) => {
+    version = version.trim();
+    if (/^v\d/.test(version)) {
+        version = version.slice(1);
+    }
+    return version;
+};
+/**
+ * 获取有效的版本号，如果符合规范则返回，否则返回null
+ * eg: getValidVersion('v1.2.3') // '1.2.3'
+ */
+export const getValidVersion = (version) => {
+    version = removeFirstV(version);
+    return versionRegex.test(version) ? version : null;
+};
+/**
+ * 解析版本号，如果符合规范则返回一个包含版本信息的对象
+ */
+export const parseVersion = (version) => {
+    version = removeFirstV(version);
+    const match = version.match(versionRegex);
+    if (match?.length) {
+        return {
+            version: match[0],
+            major: +match[1],
+            minor: +match[2],
+            patch: +match[3],
+            prerelease: match[4]?.split('.').map(str => {
+                if (/^\d*$/.test(str)) {
+                    return +str;
+                }
+                return str;
+            }) || [],
+        };
+    }
+};
+const _getCompare = (operator) => (v1, v2) => compare(v1, v2, operator);
+/**
+ * 使用给定规则比较两个版本
+ * lt: v1小于v2;  gt: v1大于v2;  lte: v1小于等于v2;  gte: v1大于等于v2;
+ * eg: compareVersion.lt('1.2.3', '9.8.7') // true
+ *     compareVersion.cmp('1.2.3', '9.8.7', '<') // true
+ */
+export const compareVersion = {
+    lt: _getCompare('<'),
+    gt: _getCompare('>'),
+    eq: _getCompare('='),
+    lte: _getCompare('<='),
+    gte: _getCompare('>='),
+    cmp: compare,
+};
+// 允许使用宽松的版本号进行 minor 版本比较
+export const compareMinorVersion = (v1, v2) => {
+    const v1Arr = v1.split('.').map(v => parseInt(v));
+    const v2Arr = v2.split('.').map(v => parseInt(v));
+    for (let i = 0; i < 2; i++) {
+        const v1Part = v1Arr[i] || 0;
+        const v2Part = v2Arr[i] || 0;
+        if (v1Part > v2Part) {
+            return 1;
+        }
+        if (v1Part < v2Part) {
+            return -1;
+        }
+    }
+    return 0;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/with-load-state.mjs

@@ -0,0 +1,21 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { of, catchError, map, startWith } from 'rxjs';
+export function withLoadState(input, defaultValue = null) {
+    return input.pipe(map(data => ({
+        loading: false,
+        data,
+        error: null,
+    })), startWith({
+        loading: true,
+        data: defaultValue,
+        error: null,
+    }), catchError(error => of({
+        loading: false,
+        data: defaultValue,
+        error,
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1sb2FkLXN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL3V0aWxzL3dpdGgtbG9hZC1zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxPQUFPLEVBQWMsRUFBRSxFQUFFLFVBQVUsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBUWxFLE1BQU0sVUFBVSxhQUFhLENBQzNCLEtBQW9CLEVBQ3BCLGVBQWtCLElBQUk7SUFFdEIsT0FBTyxLQUFLLENBQUMsSUFBSSxDQUNmLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDWCxPQUFPLEVBQUUsS0FBSztRQUNkLElBQUk7UUFDSixLQUFLLEVBQUUsSUFBSTtLQUNaLENBQUMsQ0FBQyxFQUNILFNBQVMsQ0FBQztRQUNSLE9BQU8sRUFBRSxJQUFJO1FBQ2IsSUFBSSxFQUFFLFlBQVk7UUFDbEIsS0FBSyxFQUFFLElBQUk7S0FDWixDQUFDLEVBQ0YsVUFBVSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQ2pCLEVBQUUsQ0FBQztRQUNELE9BQU8sRUFBRSxLQUFLO1FBQ2QsSUFBSSxFQUFFLFlBQVk7UUFDbEIsS0FBSztLQUNOLENBQUMsQ0FDSCxDQUNGLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqIEBtb2R1bGUgdXRpbHNcbiAqL1xuXG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBvZiwgY2F0Y2hFcnJvciwgbWFwLCBzdGFydFdpdGggfSBmcm9tICdyeGpzJztcblxuZXhwb3J0IGludGVyZmFjZSBXaXRoTG9hZFN0YXRlPFQsIEUgPSB1bmtub3duPiB7XG4gIGxvYWRpbmc6IGJvb2xlYW47XG4gIGRhdGE6IFQ7XG4gIGVycm9yOiBFO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gd2l0aExvYWRTdGF0ZTxUPihcbiAgaW5wdXQ6IE9ic2VydmFibGU8VD4sXG4gIGRlZmF1bHRWYWx1ZTogVCA9IG51bGwsXG4pOiBPYnNlcnZhYmxlPFdpdGhMb2FkU3RhdGU8VD4+IHtcbiAgcmV0dXJuIGlucHV0LnBpcGUoXG4gICAgbWFwKGRhdGEgPT4gKHtcbiAgICAgIGxvYWRpbmc6IGZhbHNlLFxuICAgICAgZGF0YSxcbiAgICAgIGVycm9yOiBudWxsLFxuICAgIH0pKSxcbiAgICBzdGFydFdpdGgoe1xuICAgICAgbG9hZGluZzogdHJ1ZSxcbiAgICAgIGRhdGE6IGRlZmF1bHRWYWx1ZSxcbiAgICAgIGVycm9yOiBudWxsLFxuICAgIH0pLFxuICAgIGNhdGNoRXJyb3IoZXJyb3IgPT5cbiAgICAgIG9mKHtcbiAgICAgICAgbG9hZGluZzogZmFsc2UsXG4gICAgICAgIGRhdGE6IGRlZmF1bHRWYWx1ZSxcbiAgICAgICAgZXJyb3IsXG4gICAgICB9KSxcbiAgICApLFxuICApO1xufVxuIl19

package/esm2022/utils/workload.mjs

@@ -0,0 +1,183 @@
+import { get } from 'lodash-es';
+import { GenericStatusColor, GenericStatusIcon, } from '../constants/status-icons';
+export var WorkloadKind;
+(function (WorkloadKind) {
+    WorkloadKind["Deployment"] = "Deployment";
+    WorkloadKind["StatefulSet"] = "StatefulSet";
+    WorkloadKind["DaemonSet"] = "DaemonSet";
+})(WorkloadKind || (WorkloadKind = {}));
+export var JobStatusEnum;
+(function (JobStatusEnum) {
+    JobStatusEnum["EXECUTING"] = "executing";
+    JobStatusEnum["EXECUTE_SUCCEEDED"] = "execute_succeeded";
+    JobStatusEnum["EXECUTE_FAILED"] = "execute_failed";
+    JobStatusEnum["UNKNOWN"] = "unknown";
+})(JobStatusEnum || (JobStatusEnum = {}));
+export const JobStatusColorMapper = {
+    [JobStatusEnum.EXECUTING]: GenericStatusColor.Pending,
+    [JobStatusEnum.EXECUTE_SUCCEEDED]: GenericStatusColor.Succeeded,
+    [JobStatusEnum.EXECUTE_FAILED]: GenericStatusColor.Failed,
+    [JobStatusEnum.UNKNOWN]: GenericStatusColor.Empty,
+};
+export const JobStatusIconMapper = {
+    [JobStatusEnum.EXECUTING]: GenericStatusIcon.Pending,
+    [JobStatusEnum.EXECUTE_SUCCEEDED]: GenericStatusIcon.Check,
+    [JobStatusEnum.EXECUTE_FAILED]: GenericStatusIcon.Error,
+    [JobStatusEnum.UNKNOWN]: GenericStatusIcon.Question,
+};
+export var WorkloadStatusEnum;
+(function (WorkloadStatusEnum) {
+    WorkloadStatusEnum["running"] = "running";
+    WorkloadStatusEnum["stopped"] = "stopped";
+    WorkloadStatusEnum["pending"] = "pending";
+    WorkloadStatusEnum["killed"] = "killed";
+})(WorkloadStatusEnum || (WorkloadStatusEnum = {}));
+export const WorkloadStatusColorMapper = {
+    [WorkloadStatusEnum.running]: GenericStatusColor.Running,
+    [WorkloadStatusEnum.pending]: GenericStatusColor.Pending,
+    [WorkloadStatusEnum.stopped]: GenericStatusColor.Stopped,
+    [WorkloadStatusEnum.killed]: GenericStatusColor.Stopped,
+};
+export const WorkloadStatusIconMapper = {
+    [WorkloadStatusEnum.running]: GenericStatusIcon.Running,
+    [WorkloadStatusEnum.pending]: GenericStatusIcon.Pending,
+    [WorkloadStatusEnum.stopped]: GenericStatusIcon.Stopped,
+    [WorkloadStatusEnum.killed]: GenericStatusIcon.Stopped,
+};
+export const STATUS = 'status';
+export function parseDeploymentStatus(res) {
+    const status = res.status;
+    if (larger(res.spec.replicas, 0) &&
+        equal(status.updatedReplicas, res.spec.replicas) &&
+        equal(status.replicas, res.spec.replicas) &&
+        equal(status.availableReplicas, res.spec.replicas) &&
+        largerEqual(status.observedGeneration, res.metadata.generation)) {
+        return WorkloadStatusEnum.running;
+    }
+    if (equal(res.spec.replicas, 0) &&
+        equal(status.replicas, res.spec.replicas) &&
+        equal(status.updatedReplicas, res.spec.replicas) &&
+        equal(status.availableReplicas, res.spec.replicas) &&
+        largerEqual(status.observedGeneration, res.metadata.generation)) {
+        return WorkloadStatusEnum.stopped;
+    }
+    return WorkloadStatusEnum.pending;
+}
+export function parseDaemonSetStatus(res) {
+    const status = res.status;
+    if (larger(status.desiredNumberScheduled, 0) &&
+        largerEqual(status.observedGeneration, res.metadata.generation) &&
+        equal(status.desiredNumberScheduled, status.currentNumberScheduled) &&
+        equal(status.numberReady, status.desiredNumberScheduled) &&
+        equal(status.numberAvailable, status.desiredNumberScheduled) &&
+        (res.spec.updateStrategy.type !== 'RollingUpdate' ||
+            equal(status.updatedNumberScheduled, status.desiredNumberScheduled))) {
+        return WorkloadStatusEnum.running;
+    }
+    if (equal(status.desiredNumberScheduled, 0) &&
+        largerEqual(status.observedGeneration, res.metadata.generation) &&
+        equal(status.desiredNumberScheduled, status.desiredNumberScheduled) &&
+        equal(status.numberReady, status.desiredNumberScheduled) &&
+        equal(status.numberAvailable, status.desiredNumberScheduled) &&
+        equal(status.currentNumberScheduled, status.desiredNumberScheduled) &&
+        (res.spec.updateStrategy.type !== 'RollingUpdate' ||
+            equal(status.updatedNumberScheduled, status.desiredNumberScheduled))) {
+        return WorkloadStatusEnum.stopped;
+    }
+    return WorkloadStatusEnum.pending;
+}
+export function parseStatefulSetStatus(res) {
+    const status = res.status;
+    if (larger(res.spec.replicas, 0) &&
+        equal(status.replicas, res.spec.replicas) &&
+        equal(status.readyReplicas, res.spec.replicas) &&
+        largerEqual(status.observedGeneration, res.metadata.generation) &&
+        (res.spec.updateStrategy.type !== 'RollingUpdate' ||
+            (equal(status.currentRevision, status.updateRevision)
+                ? equal(status.currentReplicas, res.spec.replicas)
+                : largerEqual(status?.updatedReplicas, status.replicas - +res.spec.updateStrategy.rollingUpdate?.partition)))) {
+        return WorkloadStatusEnum.running;
+    }
+    if (equal(res.spec.replicas, 0) &&
+        equal(status.replicas, res.spec.replicas) &&
+        equal(status.readyReplicas, res.spec.replicas) &&
+        largerEqual(status.observedGeneration, res.metadata.generation) &&
+        (res.spec.updateStrategy.type !== 'RollingUpdate' ||
+            (equal(status.currentRevision, status.updateRevision) &&
+                equal(status.currentReplicas, res.spec.replicas)))) {
+        return WorkloadStatusEnum.stopped;
+    }
+    return WorkloadStatusEnum.pending;
+}
+export function parseToWorkloadStatus(data) {
+    switch (data?.kind) {
+        case WorkloadKind.Deployment: {
+            return {
+                status: parseDeploymentStatus(data),
+                desired: get(data, ['spec', 'replicas'], 0),
+                current: get(data, [STATUS, 'availableReplicas'], 0),
+            };
+        }
+        case WorkloadKind.DaemonSet: {
+            return {
+                status: parseDaemonSetStatus(data),
+                desired: get(data, [STATUS, 'desiredNumberScheduled'], 0),
+                current: get(data, [STATUS, 'numberReady'], 0),
+            };
+        }
+        case WorkloadKind.StatefulSet: {
+            return {
+                status: parseStatefulSetStatus(data),
+                desired: get(data, ['spec', 'replicas'], 0),
+                current: get(data, [STATUS, 'readyReplicas'], 0),
+            };
+        }
+        default: {
+            return {
+                status: WorkloadStatusEnum.stopped,
+                desired: 0,
+                current: 0,
+            };
+        }
+    }
+}
+function equal(x, y) {
+    return defaultZero(x) === defaultZero(y);
+}
+function largerEqual(x, y) {
+    return defaultZero(x) >= defaultZero(y);
+}
+function larger(x, y) {
+    return defaultZero(x) > defaultZero(y);
+}
+function defaultZero(x) {
+    return x || 0;
+}
+export function getJobStatus(data) {
+    const status = data.status;
+    if (status.conditions?.some(_item => _item.type === 'Failed')) {
+        return JobStatusEnum.EXECUTE_FAILED;
+    }
+    // when Complete and succeeded, judge to execute_succeeded
+    if (status.conditions?.some(_item => _item.type === 'Complete')) {
+        if (status.succeeded) {
+            return JobStatusEnum.EXECUTE_SUCCEEDED;
+        }
+        if (status.failed) {
+            return JobStatusEnum.EXECUTE_FAILED;
+        }
+    }
+    // no condition and no Complete when running
+    if (status.active) {
+        return JobStatusEnum.EXECUTING;
+    }
+    return JobStatusEnum.UNKNOWN;
+}
+export function getWorkloadStatus(status) {
+    return status.status.toLowerCase();
+}
+export function getPodIPs(pod) {
+    const podIPs = pod.status.podIPs?.map(({ ip }) => ip);
+    return podIPs?.length ? podIPs : [pod.status.podIP].filter(Boolean);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workload.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/utils/workload.ts"],"names":[],"mappings":"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","sourcesContent":["import { get } from 'lodash-es';\n\nimport {\n  GenericStatusColor,\n  GenericStatusIcon,\n} from '../constants/status-icons';\nimport { DaemonSet, Deployment, Job, Pod, StatefulSet } from '../types';\n\nexport type Workload = Deployment | StatefulSet | DaemonSet;\n\nexport enum WorkloadKind {\n  Deployment = 'Deployment',\n  StatefulSet = 'StatefulSet',\n  DaemonSet = 'DaemonSet',\n}\n\nexport enum JobStatusEnum {\n  EXECUTING = 'executing',\n  EXECUTE_SUCCEEDED = 'execute_succeeded',\n  EXECUTE_FAILED = 'execute_failed',\n  UNKNOWN = 'unknown', // 比如 namespace pod 数量达到限额上限，任务就会只触发，但是没有状态\n}\n\nexport const JobStatusColorMapper = {\n  [JobStatusEnum.EXECUTING]: GenericStatusColor.Pending,\n  [JobStatusEnum.EXECUTE_SUCCEEDED]: GenericStatusColor.Succeeded,\n  [JobStatusEnum.EXECUTE_FAILED]: GenericStatusColor.Failed,\n  [JobStatusEnum.UNKNOWN]: GenericStatusColor.Empty,\n};\n\nexport const JobStatusIconMapper = {\n  [JobStatusEnum.EXECUTING]: GenericStatusIcon.Pending,\n  [JobStatusEnum.EXECUTE_SUCCEEDED]: GenericStatusIcon.Check,\n  [JobStatusEnum.EXECUTE_FAILED]: GenericStatusIcon.Error,\n  [JobStatusEnum.UNKNOWN]: GenericStatusIcon.Question,\n};\n\nexport enum WorkloadStatusEnum {\n  running = 'running',\n  stopped = 'stopped',\n  pending = 'pending',\n  killed = 'killed',\n}\n\nexport interface GenericWorkloadStatus {\n  status?: WorkloadStatusEnum;\n  desired?: number;\n  current?: number;\n}\n\nexport interface WorkloadStatus extends GenericWorkloadStatus {\n  name?: string;\n  group?: string;\n  kind?: string;\n  messages?: Array<{\n    message: string;\n    reason?: string;\n  }>;\n}\n\nexport const WorkloadStatusColorMapper = {\n  [WorkloadStatusEnum.running]: GenericStatusColor.Running,\n  [WorkloadStatusEnum.pending]: GenericStatusColor.Pending,\n  [WorkloadStatusEnum.stopped]: GenericStatusColor.Stopped,\n  [WorkloadStatusEnum.killed]: GenericStatusColor.Stopped,\n};\n\nexport const WorkloadStatusIconMapper = {\n  [WorkloadStatusEnum.running]: GenericStatusIcon.Running,\n  [WorkloadStatusEnum.pending]: GenericStatusIcon.Pending,\n  [WorkloadStatusEnum.stopped]: GenericStatusIcon.Stopped,\n  [WorkloadStatusEnum.killed]: GenericStatusIcon.Stopped,\n};\n\nexport const STATUS = 'status';\n\nexport function parseDeploymentStatus(res: Deployment) {\n  const status = res.status;\n  if (\n    larger(res.spec.replicas, 0) &&\n    equal(status.updatedReplicas, res.spec.replicas) &&\n    equal(status.replicas, res.spec.replicas) &&\n    equal(status.availableReplicas, res.spec.replicas) &&\n    largerEqual(status.observedGeneration, res.metadata.generation)\n  ) {\n    return WorkloadStatusEnum.running;\n  }\n  if (\n    equal(res.spec.replicas, 0) &&\n    equal(status.replicas, res.spec.replicas) &&\n    equal(status.updatedReplicas, res.spec.replicas) &&\n    equal(status.availableReplicas, res.spec.replicas) &&\n    largerEqual(status.observedGeneration, res.metadata.generation)\n  ) {\n    return WorkloadStatusEnum.stopped;\n  }\n  return WorkloadStatusEnum.pending;\n}\n\nexport function parseDaemonSetStatus(res: DaemonSet) {\n  const status = res.status;\n  if (\n    larger(status.desiredNumberScheduled, 0) &&\n    largerEqual(status.observedGeneration, res.metadata.generation) &&\n    equal(status.desiredNumberScheduled, status.currentNumberScheduled) &&\n    equal(status.numberReady, status.desiredNumberScheduled) &&\n    equal(status.numberAvailable, status.desiredNumberScheduled) &&\n    (res.spec.updateStrategy.type !== 'RollingUpdate' ||\n      equal(status.updatedNumberScheduled, status.desiredNumberScheduled))\n  ) {\n    return WorkloadStatusEnum.running;\n  }\n  if (\n    equal(status.desiredNumberScheduled, 0) &&\n    largerEqual(status.observedGeneration, res.metadata.generation) &&\n    equal(status.desiredNumberScheduled, status.desiredNumberScheduled) &&\n    equal(status.numberReady, status.desiredNumberScheduled) &&\n    equal(status.numberAvailable, status.desiredNumberScheduled) &&\n    equal(status.currentNumberScheduled, status.desiredNumberScheduled) &&\n    (res.spec.updateStrategy.type !== 'RollingUpdate' ||\n      equal(status.updatedNumberScheduled, status.desiredNumberScheduled))\n  ) {\n    return WorkloadStatusEnum.stopped;\n  }\n  return WorkloadStatusEnum.pending;\n}\n\nexport function parseStatefulSetStatus(res: StatefulSet) {\n  const status = res.status;\n  if (\n    larger(res.spec.replicas, 0) &&\n    equal(status.replicas, res.spec.replicas) &&\n    equal(status.readyReplicas, res.spec.replicas) &&\n    largerEqual(status.observedGeneration, res.metadata.generation) &&\n    (res.spec.updateStrategy.type !== 'RollingUpdate' ||\n      (equal(status.currentRevision, status.updateRevision)\n        ? equal(status.currentReplicas, res.spec.replicas)\n        : largerEqual(\n            status?.updatedReplicas,\n            status.replicas - +res.spec.updateStrategy.rollingUpdate?.partition,\n          )))\n  ) {\n    return WorkloadStatusEnum.running;\n  }\n  if (\n    equal(res.spec.replicas, 0) &&\n    equal(status.replicas, res.spec.replicas) &&\n    equal(status.readyReplicas, res.spec.replicas) &&\n    largerEqual(status.observedGeneration, res.metadata.generation) &&\n    (res.spec.updateStrategy.type !== 'RollingUpdate' ||\n      (equal(status.currentRevision, status.updateRevision) &&\n        equal(status.currentReplicas, res.spec.replicas)))\n  ) {\n    return WorkloadStatusEnum.stopped;\n  }\n  return WorkloadStatusEnum.pending;\n}\n\nexport function parseToWorkloadStatus(data: Deployment): GenericWorkloadStatus {\n  switch (data?.kind) {\n    case WorkloadKind.Deployment: {\n      return {\n        status: parseDeploymentStatus(data),\n        desired: get(data, ['spec', 'replicas'], 0),\n        current: get(data, [STATUS, 'availableReplicas'], 0),\n      };\n    }\n    case WorkloadKind.DaemonSet: {\n      return {\n        status: parseDaemonSetStatus(data),\n        desired: get(data, [STATUS, 'desiredNumberScheduled'], 0),\n        current: get(data, [STATUS, 'numberReady'], 0),\n      };\n    }\n    case WorkloadKind.StatefulSet: {\n      return {\n        status: parseStatefulSetStatus(data),\n        desired: get(data, ['spec', 'replicas'], 0),\n        current: get(data, [STATUS, 'readyReplicas'], 0),\n      };\n    }\n    default: {\n      return {\n        status: WorkloadStatusEnum.stopped,\n        desired: 0,\n        current: 0,\n      };\n    }\n  }\n}\n\nfunction equal(x: number | string, y: number | string) {\n  return defaultZero(x) === defaultZero(y);\n}\n\nfunction largerEqual(x: number, y: number) {\n  return defaultZero(x) >= defaultZero(y);\n}\n\nfunction larger(x: number, y: number) {\n  return defaultZero(x) > defaultZero(y);\n}\n\nfunction defaultZero(x: number | string) {\n  return x || 0;\n}\n\nexport function getJobStatus(data: Job): JobStatusEnum {\n  const status = data.status;\n  if (status.conditions?.some(_item => _item.type === 'Failed')) {\n    return JobStatusEnum.EXECUTE_FAILED;\n  }\n  // when Complete and succeeded, judge to execute_succeeded\n  if (status.conditions?.some(_item => _item.type === 'Complete')) {\n    if (status.succeeded) {\n      return JobStatusEnum.EXECUTE_SUCCEEDED;\n    }\n    if (status.failed) {\n      return JobStatusEnum.EXECUTE_FAILED;\n    }\n  }\n  // no condition and no Complete when running\n  if (status.active) {\n    return JobStatusEnum.EXECUTING;\n  }\n  return JobStatusEnum.UNKNOWN;\n}\n\nexport function getWorkloadStatus(status: GenericWorkloadStatus) {\n  return status.status.toLowerCase() as WorkloadStatusEnum;\n}\n\nexport function getPodIPs(pod: Pod) {\n  const podIPs = pod.status.podIPs?.map(({ ip }) => ip);\n  return podIPs?.length ? podIPs : [pod.status.podIP].filter(Boolean);\n}\n"]}