@alauda-fe/workload-util-shared 0.0.1

package/esm2022/lib/utils/pod-util.mjs

@@ -0,0 +1,75 @@
+import { formatCPU, formatMemory, } from '@alauda-fe/common';
+const getAppContainerResourceRequirements = (containers, type = 'limits') => {
+    return containers.reduce((acc, container) => {
+        const resources = getContainerResource(container, type);
+        Object.keys(resources).forEach(key => {
+            acc[key] =
+                (acc[key] || 0) + (isNaN(resources[key]) ? 0 : resources[key]);
+        });
+        return acc;
+    }, {});
+};
+const getInitContainerResourceRequirements = (containers, type = 'limits') => {
+    return containers.reduce((acc, container) => {
+        const resources = getContainerResource(container, type);
+        Object.keys(resources).forEach(key => {
+            acc[key] = Math.max(acc[key] || 0, isNaN(resources[key]) ? 0 : resources[key]);
+        });
+        return acc;
+    }, {});
+};
+/**
+ *  @see https://stupefied-goodall-e282f7.netlify.app/contributors/design-proposals/node/container-init/
+ *  @param pod pod resource
+ *  @returns {cpu: number | string, memory: number| string} 如果 cpu 或 memory 是 '', 则认为无限制,
+ *           如果存在扩展资源配额，比如  {nvidia.com/gpu: string, tencent.com/vcuda-memory: string} 也会进行返回，
+ *           扩展资源默认不带单位，因此可以直接进行想加
+ */
+export function getPodResourceRequirements(pod, type = 'limits') {
+    const { containers = [], initContainers = [] } = pod.spec;
+    const appContainerLimit = getAppContainerResourceRequirements(containers, type);
+    const initContainerLimit = getInitContainerResourceRequirements(initContainers, type);
+    const result = {};
+    // 合并所有的资源类型
+    const allResourceTypes = new Set([
+        ...Object.keys(appContainerLimit),
+        ...Object.keys(initContainerLimit),
+    ]);
+    allResourceTypes.forEach(resourceType => {
+        const appValue = appContainerLimit[resourceType] || 0;
+        const initValue = initContainerLimit[resourceType] || 0;
+        const maxValue = Math.max(appValue, initValue);
+        result[resourceType] = isNaN(maxValue) ? '' : maxValue;
+    });
+    return result;
+}
+export function getContainerResourceLimit(container) {
+    return getContainerResource(container, 'limits');
+}
+export function getContainerResourceRequest(container) {
+    return getContainerResource(container, 'requests');
+}
+function getContainerResource(container, type) {
+    const result = {};
+    const resources = container.resources[type] || {};
+    Object.entries(resources).forEach(([key, value]) => {
+        if (value === '') {
+            result[key] = NaN;
+        }
+        else if (key === 'cpu') {
+            if (!isNaN(+value)) {
+                value += 'c';
+            }
+            result[key] = formatCPU(value);
+        }
+        else if (key === 'memory') {
+            result[key] = formatMemory(value);
+        }
+        else {
+            // 对于其他资源类型（如 GPU 或自定义资源），直接使用数值
+            result[key] = parseFloat(value) || NaN;
+        }
+    });
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pod-util.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/pod-util.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Container,\n  Pod,\n  ResourceRequirements,\n  formatCPU,\n  formatMemory,\n} from '@alauda-fe/common';\n\nconst getAppContainerResourceRequirements = (\n  containers: Container[],\n  type: keyof ResourceRequirements = 'limits',\n) => {\n  return containers.reduce(\n    (acc, container) => {\n      const resources = getContainerResource(container, type);\n      Object.keys(resources).forEach(key => {\n        acc[key] =\n          (acc[key] || 0) + (isNaN(resources[key]) ? 0 : resources[key]);\n      });\n      return acc;\n    },\n    {} as { [key: string]: number },\n  );\n};\n\nconst getInitContainerResourceRequirements = (\n  containers: Container[],\n  type: keyof ResourceRequirements = 'limits',\n) => {\n  return containers.reduce(\n    (acc, container) => {\n      const resources = getContainerResource(container, type);\n      Object.keys(resources).forEach(key => {\n        acc[key] = Math.max(\n          acc[key] || 0,\n          isNaN(resources[key]) ? 0 : resources[key],\n        );\n      });\n      return acc;\n    },\n    {} as { [key: string]: number },\n  );\n};\n\n/**\n *  @see https://stupefied-goodall-e282f7.netlify.app/contributors/design-proposals/node/container-init/\n *  @param pod pod resource\n *  @returns {cpu: number | string, memory: number| string} 如果 cpu 或 memory 是 '', 则认为无限制,\n *           如果存在扩展资源配额，比如  {nvidia.com/gpu: string, tencent.com/vcuda-memory: string} 也会进行返回，\n *           扩展资源默认不带单位，因此可以直接进行想加\n */\nexport function getPodResourceRequirements(\n  pod: Pod,\n  type: keyof ResourceRequirements = 'limits',\n): {\n  cpu: number | string;\n  memory: number | string;\n  [key: string]: number | string;\n} {\n  const { containers = [], initContainers = [] } = pod.spec;\n  const appContainerLimit = getAppContainerResourceRequirements(\n    containers,\n    type,\n  );\n  const initContainerLimit = getInitContainerResourceRequirements(\n    initContainers,\n    type,\n  );\n\n  const result: { [key: string]: number | string } = {};\n\n  // 合并所有的资源类型\n  const allResourceTypes = new Set([\n    ...Object.keys(appContainerLimit),\n    ...Object.keys(initContainerLimit),\n  ]);\n\n  allResourceTypes.forEach(resourceType => {\n    const appValue = appContainerLimit[resourceType] || 0;\n    const initValue = initContainerLimit[resourceType] || 0;\n    const maxValue = Math.max(appValue, initValue);\n    result[resourceType] = isNaN(maxValue) ? '' : maxValue;\n  });\n\n  return result as {\n    cpu: number | string;\n    memory: number | string;\n    [key: string]: number | string;\n  };\n}\n\nexport function getContainerResourceLimit(container: Container): {\n  [key: string]: number;\n} {\n  return getContainerResource(container, 'limits');\n}\n\nexport function getContainerResourceRequest(container: Container): {\n  [key: string]: number;\n} {\n  return getContainerResource(container, 'requests');\n}\n\nfunction getContainerResource(\n  container: Container,\n  type: 'requests' | 'limits',\n): { [key: string]: number } {\n  const result: { [key: string]: number } = {};\n  const resources = container.resources[type] || {};\n\n  Object.entries(resources).forEach(([key, value]) => {\n    if (value === '') {\n      result[key] = NaN;\n    } else if (key === 'cpu') {\n      if (!isNaN(+value)) {\n        value += 'c';\n      }\n      result[key] = formatCPU(value);\n    } else if (key === 'memory') {\n      result[key] = formatMemory(value);\n    } else {\n      // 对于其他资源类型（如 GPU 或自定义资源），直接使用数值\n      result[key] = parseFloat(value) || NaN;\n    }\n  });\n\n  return result;\n}\n"]}

package/esm2022/lib/utils/resource-status.mjs

@@ -0,0 +1,86 @@
+import { AlarmStatus } from '@alauda-fe/alarm';
+import { HelmRequestPhaseEnum, } from '@alauda-fe/common';
+import { ApplicationPhaseEnum, ApplicationStateEnum, ApplicationStatusEnum, HelmRequestStatusEnum, JobStatusEnum, } from '../typings';
+export function getAlarmStatus(rule) {
+    if (rule.labels.alarm_status?.toLowerCase() === 'pending') {
+        return AlarmStatus.Pending;
+    }
+    if (rule.labels.alarm_status?.toLowerCase() === 'firing') {
+        return AlarmStatus.Firing;
+    }
+    return AlarmStatus.Normal;
+}
+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 getApplicationStatus(application) {
+    const status = application.status;
+    const phase = application.spec.assemblyPhase;
+    if (phase === ApplicationPhaseEnum.Succeeded) {
+        switch (status.state) {
+            case ApplicationStateEnum.Stopped: {
+                return ApplicationStatusEnum.STOPPED;
+            }
+            case ApplicationStateEnum.Pending: {
+                return ApplicationStatusEnum.PENDING;
+            }
+            case ApplicationStateEnum.Running: {
+                return ApplicationStatusEnum.RUNNING;
+            }
+            case ApplicationStateEnum.PartialRunning: {
+                return ApplicationStatusEnum.PARTIAL_RUNNING;
+            }
+            case ApplicationStateEnum.Empty: {
+                return ApplicationStatusEnum.NO_WORKLOAD;
+            }
+            default: {
+                return ApplicationStatusEnum.UNKNOWN;
+            }
+        }
+    }
+    switch (phase) {
+        case ApplicationPhaseEnum.Pending: {
+            return ApplicationStatusEnum.PENDING;
+        }
+        case ApplicationPhaseEnum.Failed: {
+            return ApplicationStatusEnum.FAILED;
+        }
+    }
+}
+export function getHelmRequestStatus(hr) {
+    if (hr.status) {
+        switch (hr.status.phase) {
+            case HelmRequestPhaseEnum.Synced: {
+                return HelmRequestStatusEnum.DEPLOY_SUCCEEDED;
+            }
+            case HelmRequestPhaseEnum.Failed: {
+                return HelmRequestStatusEnum.DEPLOY_FAILED;
+            }
+            case HelmRequestPhaseEnum.Pending: {
+                return HelmRequestStatusEnum.DEPLOYING;
+            }
+        }
+    }
+    return HelmRequestStatusEnum.DEPLOYING;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/resources-config-util.mjs

@@ -0,0 +1,28 @@
+export function getCustomResourceLimitsDisplay(configs, resources) {
+    return getCustomResourceDisplay(configs, resources, 'limits');
+}
+export function getCustomResourceRequestsDisplay(configs, resources) {
+    return getCustomResourceDisplay(configs, resources, 'requests');
+}
+export function getCustomResourceDisplay(configs, resources, type) {
+    if (!configs?.length) {
+        return [];
+    }
+    const res = resources[type] || {};
+    return Object.keys(res)
+        .filter(key => !['memory', 'cpu'].includes(key) &&
+        configs?.some(config => config.key === key))
+        .map(key => {
+        const config = configs.find(config => config.key === key);
+        return {
+            label: config.labelZh
+                ? {
+                    en: config.labelEn,
+                    zh: config.labelZh,
+                }
+                : config.key,
+            value: res[key],
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/status.mjs

@@ -0,0 +1,84 @@
+import { PodStatusEnum } from '@alauda-fe/common';
+import { get } from 'lodash-es';
+// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/pod.go#lines-179
+export function getPodStatus(pod) {
+    let reason = pod.status.phase || pod.status.reason;
+    const { initializing, reason: initReason } = getPodInitStatus(pod, reason);
+    reason = initializing ? initReason : getPodContainerStatus(pod, reason);
+    if (pod.metadata.deletionTimestamp && pod.status.reason === 'NodeLost') {
+        reason = 'Unknown';
+    }
+    else if (pod.metadata.deletionTimestamp) {
+        reason = 'Terminating';
+    }
+    return reason;
+}
+function getPodContainerStatus(pod, reason) {
+    const containerStatuses = get(pod, ['status', 'containerStatuses'], []);
+    for (let i = 0, len = containerStatuses.length; i < len; i++) {
+        const container = containerStatuses[i];
+        let waitingReason, terminatedReason;
+        if ((waitingReason = get(container, ['state', 'waiting', 'reason']))) {
+            return waitingReason;
+        }
+        if ((terminatedReason = get(container, ['state', 'terminated', 'reason']))) {
+            return terminatedReason;
+        }
+        if (get(container, ['state', 'terminated'])) {
+            const { signal, exitCode } = container.state.terminated;
+            return signal === 0 ? `ExitCode:${exitCode}` : `Signal:${signal}`;
+        }
+    }
+    return reason;
+}
+function getPodInitStatus(pod, reason) {
+    let initializing = false;
+    const initContainerStatuses = get(pod, ['status', 'initContainerStatuses'], []);
+    for (let i = initContainerStatuses.length - 1; i >= 0; i--) {
+        const status = initContainerStatuses[i];
+        if (get(status, ['state', 'terminated', 'exitCode']) === 0) {
+            continue;
+        }
+        let waitingReason;
+        const terminated = get(status, ['state', 'terminated']);
+        if (terminated) {
+            reason = terminated.reason
+                ? `Init:${terminated.reason}`
+                : terminated.signal === 0
+                    ? `Init:ExitCode:${terminated.exitCode}`
+                    : `Init:Signal:${terminated.signal}`;
+        }
+        else if ((waitingReason = get(status, ['state', 'waiting', reason])) &&
+            waitingReason !== 'PodInitializing') {
+            reason = `Initing:${waitingReason}`;
+        }
+        else {
+            reason = `Initing:${i}/${pod.spec.initContainers.length}`;
+        }
+        initializing = true;
+        break;
+    }
+    return { initializing, reason };
+}
+// 将 getPodStatus 得到的多种状态映射到标签类型
+// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/podinfo.go#lines-68
+export function getPodAggregatedStatus(status) {
+    if (status.split(':')[0] === 'Initing' ||
+        [
+            'Initing',
+            'Pending',
+            'PodInitializing',
+            'ContainerCreating',
+            'Terminating',
+        ].includes(status)) {
+        return PodStatusEnum.pending;
+    }
+    if (status === 'Completed') {
+        return PodStatusEnum.completed;
+    }
+    if (status === 'Running') {
+        return PodStatusEnum.running;
+    }
+    return PodStatusEnum.error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACxE,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAEhC,+IAA+I;AAC/I,MAAM,UAAU,YAAY,CAAC,GAAQ;IACnC,IAAI,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC;IACnD,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC3E,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,qBAAqB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAExE,IAAI,GAAG,CAAC,QAAQ,CAAC,iBAAiB,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;QACvE,MAAM,GAAG,SAAS,CAAC;IACrB,CAAC;SAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC;QAC1C,MAAM,GAAG,aAAa,CAAC;IACzB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,qBAAqB,CAAC,GAAQ,EAAE,MAAc;IACrD,MAAM,iBAAiB,GAAsB,GAAG,CAC9C,GAAG,EACH,CAAC,QAAQ,EAAE,mBAAmB,CAAC,EAC/B,EAAE,CACH,CAAC;IACF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7D,MAAM,SAAS,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;QACvC,IAAI,aAAa,EAAE,gBAAgB,CAAC;QACpC,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;YACrE,OAAO,aAAa,CAAC;QACvB,CAAC;QACD,IACE,CAAC,gBAAgB,GAAG,GAAG,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,EACtE,CAAC;YACD,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC;YAC5C,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC;YACxD,OAAO,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,YAAY,QAAQ,EAAE,CAAC,CAAC,CAAC,UAAU,MAAM,EAAE,CAAC;QACpE,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,gBAAgB,CAAC,GAAQ,EAAE,MAAc;IAChD,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,MAAM,qBAAqB,GAAG,GAAG,CAC/B,GAAG,EACH,CAAC,QAAQ,EAAE,uBAAuB,CAAC,EACnC,EAAuB,CACxB,CAAC;IACF,KAAK,IAAI,CAAC,GAAG,qBAAqB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3D,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3D,SAAS;QACX,CAAC;QACD,IAAI,aAAqB,CAAC;QAC1B,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;QACxD,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,GAAG,UAAU,CAAC,MAAM;gBACxB,CAAC,CAAC,QAAQ,UAAU,CAAC,MAAM,EAAE;gBAC7B,CAAC,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;oBACvB,CAAC,CAAC,iBAAiB,UAAU,CAAC,QAAQ,EAAE;oBACxC,CAAC,CAAC,eAAe,UAAU,CAAC,MAAM,EAAE,CAAC;QAC3C,CAAC;aAAM,IACL,CAAC,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;YAC3D,aAAa,KAAK,iBAAiB,EACnC,CAAC;YACD,MAAM,GAAG,WAAW,aAAa,EAAE,CAAC;QACtC,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,WAAW,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;QAC5D,CAAC;QACD,YAAY,GAAG,IAAI,CAAC;QACpB,MAAM;IACR,CAAC;IACD,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;AAClC,CAAC;AAED,gCAAgC;AAChC,kJAAkJ;AAClJ,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACnD,IACE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,SAAS;QAClC;YACE,SAAS;YACT,SAAS;YACT,iBAAiB;YACjB,mBAAmB;YACnB,aAAa;SACd,CAAC,QAAQ,CAAC,MAAM,CAAC,EAClB,CAAC;QACD,OAAO,aAAa,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,IAAI,MAAM,KAAK,WAAW,EAAE,CAAC;QAC3B,OAAO,aAAa,CAAC,SAAS,CAAC;IACjC,CAAC;IACD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,aAAa,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,OAAO,aAAa,CAAC,KAAK,CAAC;AAC7B,CAAC","sourcesContent":["import { ContainerStatus, Pod, PodStatusEnum } from '@alauda-fe/common';\nimport { get } from 'lodash-es';\n\n// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/pod.go#lines-179\nexport function getPodStatus(pod: Pod): string {\n  let reason = pod.status.phase || pod.status.reason;\n  const { initializing, reason: initReason } = getPodInitStatus(pod, reason);\n  reason = initializing ? initReason : getPodContainerStatus(pod, reason);\n\n  if (pod.metadata.deletionTimestamp && pod.status.reason === 'NodeLost') {\n    reason = 'Unknown';\n  } else if (pod.metadata.deletionTimestamp) {\n    reason = 'Terminating';\n  }\n  return reason;\n}\n\nfunction getPodContainerStatus(pod: Pod, reason: string): string {\n  const containerStatuses: ContainerStatus[] = get(\n    pod,\n    ['status', 'containerStatuses'],\n    [],\n  );\n  for (let i = 0, len = containerStatuses.length; i < len; i++) {\n    const container = containerStatuses[i];\n    let waitingReason, terminatedReason;\n    if ((waitingReason = get(container, ['state', 'waiting', 'reason']))) {\n      return waitingReason;\n    }\n    if (\n      (terminatedReason = get(container, ['state', 'terminated', 'reason']))\n    ) {\n      return terminatedReason;\n    }\n    if (get(container, ['state', 'terminated'])) {\n      const { signal, exitCode } = container.state.terminated;\n      return signal === 0 ? `ExitCode:${exitCode}` : `Signal:${signal}`;\n    }\n  }\n  return reason;\n}\n\nfunction getPodInitStatus(pod: Pod, reason: string) {\n  let initializing = false;\n  const initContainerStatuses = get(\n    pod,\n    ['status', 'initContainerStatuses'],\n    [] as ContainerStatus[],\n  );\n  for (let i = initContainerStatuses.length - 1; i >= 0; i--) {\n    const status = initContainerStatuses[i];\n    if (get(status, ['state', 'terminated', 'exitCode']) === 0) {\n      continue;\n    }\n    let waitingReason: string;\n    const terminated = get(status, ['state', 'terminated']);\n    if (terminated) {\n      reason = terminated.reason\n        ? `Init:${terminated.reason}`\n        : terminated.signal === 0\n          ? `Init:ExitCode:${terminated.exitCode}`\n          : `Init:Signal:${terminated.signal}`;\n    } else if (\n      (waitingReason = get(status, ['state', 'waiting', reason])) &&\n      waitingReason !== 'PodInitializing'\n    ) {\n      reason = `Initing:${waitingReason}`;\n    } else {\n      reason = `Initing:${i}/${pod.spec.initContainers.length}`;\n    }\n    initializing = true;\n    break;\n  }\n  return { initializing, reason };\n}\n\n// 将 getPodStatus 得到的多种状态映射到标签类型\n// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/podinfo.go#lines-68\nexport function getPodAggregatedStatus(status: string): PodStatusEnum {\n  if (\n    status.split(':')[0] === 'Initing' ||\n    [\n      'Initing',\n      'Pending',\n      'PodInitializing',\n      'ContainerCreating',\n      'Terminating',\n    ].includes(status)\n  ) {\n    return PodStatusEnum.pending;\n  }\n\n  if (status === 'Completed') {\n    return PodStatusEnum.completed;\n  }\n  if (status === 'Running') {\n    return PodStatusEnum.running;\n  }\n\n  return PodStatusEnum.error;\n}\n"]}

package/esm2022/lib/utils/validator.mjs

@@ -0,0 +1,11 @@
+import { K8S_ENV_VARIABLE_NAME } from './patterns';
+export function envVarNameValidator(control) {
+    return !control.value ||
+        (K8S_ENV_VARIABLE_NAME.pattern.test(control.value) &&
+            !/^\.+$/.test(control.value))
+        ? null
+        : {
+            envVarNamePattern: true,
+        };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy93b3JrbG9hZC91dGlsLXNoYXJlZC9zcmMvbGliL3V0aWxzL3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFbkQsTUFBTSxVQUFVLG1CQUFtQixDQUFDLE9BQWdDO0lBQ2xFLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSztRQUNuQixDQUFDLHFCQUFxQixDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztZQUNoRCxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQy9CLENBQUMsQ0FBQyxJQUFJO1FBQ04sQ0FBQyxDQUFDO1lBQ0UsaUJBQWlCLEVBQUUsSUFBSTtTQUN4QixDQUFDO0FBQ1IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFic3RyYWN0Q29udHJvbCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuaW1wb3J0IHsgSzhTX0VOVl9WQVJJQUJMRV9OQU1FIH0gZnJvbSAnLi9wYXR0ZXJucyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBlbnZWYXJOYW1lVmFsaWRhdG9yKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbDxzdHJpbmc+KSB7XG4gIHJldHVybiAhY29udHJvbC52YWx1ZSB8fFxuICAgIChLOFNfRU5WX1ZBUklBQkxFX05BTUUucGF0dGVybi50ZXN0KGNvbnRyb2wudmFsdWUpICYmXG4gICAgICAhL15cXC4rJC8udGVzdChjb250cm9sLnZhbHVlKSlcbiAgICA/IG51bGxcbiAgICA6IHtcbiAgICAgICAgZW52VmFyTmFtZVBhdHRlcm46IHRydWUsXG4gICAgICB9O1xufVxuIl19

package/esm2022/lib/utils/workspace.mjs

@@ -0,0 +1,25 @@
+import { ActivatedRoute, } from '@angular/router';
+export function parseWorkspace(workspace) {
+    const [project, cluster, namespace] = workspace.split('~');
+    return {
+        project,
+        cluster,
+        namespace,
+    };
+}
+export function stringifyWorkspace({ project, cluster, namespace, }) {
+    return `${project}~${cluster}~${namespace}`;
+}
+export function extractWorkspace(params) {
+    return params.get && params.get instanceof Function
+        ? parseWorkspace(params.get('workspace'))
+        : parseWorkspace(params.workspace);
+}
+export function extractWorkspaceFromRoute(route) {
+    const snapshot = route instanceof ActivatedRoute ? route.snapshot : route;
+    return parseWorkspace(snapshot.paramMap.get('workspace'));
+}
+export function getHomeRedirectRoutePrefix(snapshot) {
+    return snapshot.queryParamMap.get('redirectTo') || 'workspace';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/directives';
+export * from './lib/pipes';
+export * from './lib/services';
+export * from './lib/typings';
+export * from './lib/utils';

package/lib/directives/index.d.ts

@@ -0,0 +1,2 @@
+export * from './oam-resource-disabled-container.directive';
+export * from './sync-control.directive';

package/lib/directives/oam-resource-disabled-container.directive.d.ts

@@ -0,0 +1,17 @@
+import { DisabledContainerComponent, KubernetesResource, TranslateService } from '@alauda-fe/common';
+import { ChangeDetectorRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @description acl-disabled-container 增强指令。
+ *
+ * 需要注意对 acl-disabled-container的副作用，一旦满足 isOam 的条件，禁用的 tip 会一直保留，并且优先级最高，除非数据源本身发生变化。
+ */
+export declare class OamResourceDisabledContainerDirective {
+    private readonly disabledContainer;
+    private readonly translate;
+    private readonly cdr;
+    rcIsOamDisabled: KubernetesResource;
+    constructor(disabledContainer: DisabledContainerComponent, translate: TranslateService, cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<OamResourceDisabledContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OamResourceDisabledContainerDirective, "acl-disabled-container[rcIsOamDisabled]", never, { "rcIsOamDisabled": { "alias": "rcIsOamDisabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/directives/sync-control.directive.d.ts

@@ -0,0 +1,14 @@
+import { AfterViewInit, Injector, OnDestroy } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class SyncControlDirective implements AfterViewInit, OnDestroy {
+    private readonly injector;
+    private readonly destroy$$;
+    constructor(injector: Injector);
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    getControl(): AbstractControl;
+    private getDirective;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SyncControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SyncControlDirective, "[syncControl]", never, {}, {}, never, never, true, never>;
+}

package/lib/pipes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './is-oam-resource.pipe';
+export * from './range.pipe';
+export * from './short-num.pipe';

package/lib/pipes/is-oam-resource.pipe.d.ts

@@ -0,0 +1,9 @@
+import { KubernetesResource } from '@alauda-fe/common';
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const isOamResource: <T extends KubernetesResource>(resource: T) => boolean;
+export declare class isOamResourcePipe implements PipeTransform {
+    transform: <T extends KubernetesResource>(resource: T) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<isOamResourcePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<isOamResourcePipe, "rcIsOamResource", true>;
+}

package/lib/pipes/range.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class RangePipe implements PipeTransform {
+    transform(value: number): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", true>;
+}

package/lib/pipes/short-num.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ShortNumPipe implements PipeTransform {
+    transform(value: string | number, digits?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShortNumPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ShortNumPipe, "shortNum", true>;
+}

package/lib/services/cluster-api.service.d.ts

@@ -0,0 +1,38 @@
+import { K8sApiService, K8sUtilService, ProductBase } from '@alauda-fe/common';
+import { ClusterType } from '@alauda-fe/network';
+import { ClusterModule, ResourceType } from '../typings';
+import * as i0 from "@angular/core";
+export interface ClusterGlobalInfo {
+    chartMuseumURL: string;
+    clusterName: string;
+    clusterType: ClusterType;
+    globalClusterName: string;
+    labelBaseDomain: string;
+    oidcClientID: string;
+    oidcClientSecret: string;
+    oidcIssuer: string;
+    oidcResponseType: 'code';
+    oidcScopes: string;
+    platformHttpPort: string;
+    platformHttpsPort: string;
+    platformNodeSelector: string;
+    platformURL: string;
+    registryAddress: string;
+    systemAlbIngressClassName: string;
+    systemNamespace: string;
+}
+export declare class ClusterApiService {
+    private readonly k8sApi;
+    private readonly k8sUtil;
+    globalClusterVersion$: import("rxjs").Observable<ProductBase>;
+    private readonly globalInfoCache;
+    constructor(k8sApi: K8sApiService<ResourceType>, k8sUtil: K8sUtilService);
+    isClusterNonUpgraded(cluster: string | ClusterModule): import("rxjs").Observable<boolean>;
+    gteVersion(cluster: string | ClusterModule, version: string): import("rxjs").Observable<boolean>;
+    getGlobalInfo(cluster?: string): import("rxjs").Observable<ClusterGlobalInfo>;
+    getClusterType(cluster?: string): import("rxjs").Observable<ClusterType>;
+    isPublicCloud(cluster?: string): import("rxjs").Observable<boolean>;
+    getClusterArches(cluster?: string): import("rxjs").Observable<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClusterApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClusterApiService>;
+}

package/lib/services/feature-gate.service.d.ts

@@ -0,0 +1,38 @@
+import { KubernetesResource, KubernetesResourceList } from '@alauda-fe/common';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class FeatureGateApiService {
+    private readonly http;
+    constructor(http: HttpClient);
+    getGlobalGateList(): import("rxjs").Observable<KubernetesResourceList<FeatureGate>>;
+    getGlobalGate(name: string): import("rxjs").Observable<FeatureGate>;
+    getClusterGateList(cluster: string): import("rxjs").Observable<KubernetesResourceList<FeatureGate>>;
+    getClusterGate(cluster: string, name: string): import("rxjs").Observable<FeatureGate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureGateApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FeatureGateApiService>;
+}
+export declare function toMap(items: FeatureGate[]): Record<string, boolean>;
+export interface FeatureGate extends KubernetesResource {
+    spec: {
+        dependency: {
+            type: DependencyType;
+            featureGates: string[];
+        };
+        description: string;
+        enabled: boolean;
+        stage: FeatureStage;
+    };
+    status: {
+        enabled: boolean;
+    };
+}
+export declare enum DependencyType {
+    Any = "any",
+    All = "all"
+}
+export declare enum FeatureStage {
+    Alpha = "Alpha",
+    Beta = "Beta",
+    GA = "GA",
+    EOF = "EOF"
+}

package/lib/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cluster-api.service';
+export * from './feature-gate.service';
+export * from './pod-util.service';
+export * from './resource-quota.service';
+export * from './terminal.service';

package/lib/services/pod-util.service.d.ts

@@ -0,0 +1,18 @@
+import { DialogService } from '@alauda/ui';
+import { K8sApiService, TranslateService, Container, Pod, Workspace } from '@alauda-fe/common';
+import { ExecInfo } from '../typings';
+import { TerminalService } from './terminal.service';
+import * as i0 from "@angular/core";
+export declare const DEBUG_CONTAINER_SUFFIX = "-debug";
+export declare class PodUtilService {
+    private readonly dialog;
+    private readonly translate;
+    private readonly k8sApi;
+    private readonly terminal;
+    constructor(dialog: DialogService, translate: TranslateService, k8sApi: K8sApiService, terminal: TerminalService);
+    deletePod(pod: Pod, cluster: string): import("rxjs").Observable<Pod>;
+    handleExecInfo(pod: Pod, container: Container, baseParams: Workspace, data: ExecInfo): void;
+    handleDebugInfo(pod: Pod, container: Container, baseParams: Workspace): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PodUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PodUtilService>;
+}

package/lib/services/resource-quota.service.d.ts

@@ -0,0 +1,25 @@
+import { K8sApiService, K8sUtilService, StringMap, LimitRange, Workspace, ResourceType, ResourceRequirements } from '@alauda-fe/common';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ResourceQuotaUtilService {
+    private readonly k8sUtil;
+    private readonly k8sApi;
+    private readonly limitRange$Cache;
+    private readonly resourceQuota$Cache;
+    constructor(k8sUtil: K8sUtilService, k8sApi: K8sApiService<ResourceType>);
+    getLimitRange$({ cluster, namespace, }: {
+        cluster: string;
+        namespace: string;
+    }): Observable<LimitRange>;
+    getAvailableCustomResourceKeysInNodes(workspace: Workspace): Observable<string[]>;
+    getResourceQuota$({ cluster, namespace }: Workspace): Observable<{
+        resourceQuota: ResourceRequirements;
+        customResourceConfigs: StringMap[];
+    }>;
+    deleteCache({ cluster, namespace }: {
+        cluster: string;
+        namespace: string;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceQuotaUtilService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceQuotaUtilService>;
+}

package/lib/services/terminal.service.d.ts

@@ -0,0 +1,15 @@
+import { K8sPermissionService, K8sResourceAction } from '@alauda-fe/common';
+import { HttpParamsOptions } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class TerminalService {
+    private readonly k8sPermission;
+    private readonly appBaseHref;
+    constructor(k8sPermission: K8sPermissionService, appBaseHref: string);
+    getPermissions({ cluster, namespace, }: {
+        cluster: string;
+        namespace: string;
+    }): import("rxjs").Observable<Record<K8sResourceAction.CREATE, boolean>>;
+    openTerminal(queryParams: HttpParamsOptions['fromObject'], module?: 'terminal' | 'vnc'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TerminalService>;
+}

package/lib/typings/account.d.ts

@@ -0,0 +1,17 @@
+export interface AccountInfo {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    iat?: number;
+    azp?: string;
+    at_hash?: string;
+    email?: string;
+    email_verified?: true;
+    name?: string;
+    token?: string;
+    ext?: {
+        is_admin?: boolean;
+        conn_id?: boolean;
+    };
+}