@dao-style/biz 0.6.0 → 0.7.0

package/dist/components/gpu/src/gpuForm.mapper.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lodashEs = require("lodash-es");
+const gpuForm_constants = require("./gpuForm.constants.js");
+const types = require("../types.js");
+const utils = require("../utils.js");
+const randomStr = require("../../../utils/randomStr.js");
+const formatNumUnit = require("../../../utils/formatNumUnit.js");
+const buildGpuFormFormattedUpdate = (rows, existTypes, withPrefixRequest = false) => {
+  const currentVgpuState = {
+    nvidiaVgpuModel: "",
+    nvidiaVgpuPriority: ""
+  };
+  const resources = rows.reduce((pre, row) => {
+    const {
+      type,
+      resources: rest,
+      [types.nvidiaVgpuModelKey]: nvidiaVgpuModel,
+      [types.nvidiaVgpuDevicesKey]: nvidiaVgpuDevices,
+      [types.nvidiaVgpuPriorityKey]: nvidiaVgpuPriority,
+      [types.nvidiaVgpuGpuScheduleKey]: nvidiaVgpuGpuSchedule,
+      [types.nvidiaVgpuNodeScheduleKey]: nvidiaVgpuNodeSchedule
+    } = row;
+    const vgpuResource = Object.entries(rest ?? {}).reduce((preRes, [key, val]) => {
+      if (!utils.isValidGPUResourceValue(val)) {
+        return preRes;
+      }
+      const finalResourceKey = utils.deSanitizeGPUKey(key) ?? "";
+      Object.assign(preRes, {
+        [withPrefixRequest ? `requests.${finalResourceKey}` : finalResourceKey]: val
+      });
+      return preRes;
+    }, {});
+    Object.assign(pre, vgpuResource);
+    if (utils.isNvidiaVgpu(type)) {
+      Object.assign(currentVgpuState, {
+        nvidiaVgpuModel,
+        nvidiaVgpuDevices,
+        nvidiaVgpuPriority,
+        nvidiaVgpuGpuSchedule,
+        nvidiaVgpuNodeSchedule
+      });
+    }
+    return pre;
+  }, {});
+  return {
+    change: {
+      types: existTypes,
+      resources
+    },
+    vgpu: currentVgpuState
+  };
+};
+const filterGpuFormRows = (items, gpuOptionsMap) => {
+  const diffRows = items.filter((item) => item.type && gpuOptionsMap.has(item.type));
+  if (!diffRows.length) {
+    return [gpuForm_constants.createEmptyRow()];
+  }
+  return diffRows;
+};
+const buildGpuFormVgpuUpdateEmits = (vgpu, props, vgpuExist) => {
+  var _a;
+  const emits = [];
+  if (props.enableNvidiaVgpuModel && vgpuExist) {
+    emits.push(["update:nvidiaVgpuModel", vgpu.nvidiaVgpuModel]);
+  } else if (props.nvidiaVgpuModel) {
+    emits.push(["update:nvidiaVgpuModel", void 0]);
+  }
+  if (props.enableNvidiaVgpuDevices && vgpuExist) {
+    emits.push(["update:nvidiaVgpuDevices", vgpu.nvidiaVgpuDevices]);
+  } else if ((_a = props.nvidiaVgpuDevices) == null ? void 0 : _a.length) {
+    emits.push(["update:nvidiaVgpuDevices", void 0]);
+  }
+  if (props.enableNvidiaVgpuPriority && vgpuExist) {
+    emits.push(["update:nvidiaVgpuPriority", vgpu.nvidiaVgpuPriority]);
+  } else if (props.nvidiaVgpuPriority) {
+    emits.push(["update:nvidiaVgpuPriority", void 0]);
+  }
+  if (props.enableNvidiaVgpuSchedulePolicy && vgpuExist) {
+    emits.push(["update:nvidiaVgpuGpuSchedule", vgpu.nvidiaVgpuGpuSchedule]);
+    emits.push(["update:nvidiaVgpuNodeSchedule", vgpu.nvidiaVgpuNodeSchedule]);
+  } else if (props.nvidiaVgpuGpuSchedule || props.nvidiaVgpuNodeSchedule) {
+    emits.push(["update:nvidiaVgpuGpuSchedule", void 0]);
+    emits.push(["update:nvidiaVgpuNodeSchedule", void 0]);
+  }
+  return emits;
+};
+const buildGpuFormSideRow = ({
+  row,
+  gpuOptionsMap,
+  sideQuota,
+  withPrefixRequest = false
+}) => {
+  var _a, _b;
+  const sideRow = {
+    ...row,
+    type: (_a = row.type) == null ? void 0 : _a.toString(),
+    resources: {}
+  };
+  const currentGpuSettings = gpuOptionsMap.get(sideRow.type ?? "");
+  (_b = currentGpuSettings == null ? void 0 : currentGpuSettings.resource) == null ? void 0 : _b.forEach(({ key }) => {
+    const actualKey = withPrefixRequest ? `requests.${key}` : key;
+    const val = sideQuota == null ? void 0 : sideQuota.resources[actualKey ?? ""];
+    if (utils.isValidGPUResourceValue(val)) {
+      lodashEs.set(sideRow, ["resources", utils.sanitizeGPUKey(key) ?? ""], formatNumUnit.formatNumUnit(val));
+    }
+  });
+  return sideRow;
+};
+const buildGpuFormInitialRows = ({
+  quota,
+  availableQuota,
+  sideQuota,
+  gpuOptionsMap,
+  getDisplayResource,
+  withPrefixRequest = false,
+  showSide = false,
+  isLimitOne = false,
+  vgpu
+}) => {
+  const { types: types$1, resources } = quota;
+  const { types: availableTypes } = availableQuota ?? {};
+  const newTypes = [.../* @__PURE__ */ new Set([...availableTypes ?? [], ...types$1])];
+  const rows = [];
+  const sideRows = [];
+  newTypes.forEach((type) => {
+    if (!gpuOptionsMap.has(type)) {
+      return;
+    }
+    const row = {
+      id: randomStr.randomStr(gpuForm_constants.gpuFormRowIdLength),
+      removable: !(availableTypes == null ? void 0 : availableTypes.includes(type)),
+      type
+    };
+    const sideRow = {
+      type,
+      id: randomStr.randomStr(gpuForm_constants.gpuFormRowIdLength),
+      resources: {}
+    };
+    const displayResource = getDisplayResource(type);
+    if (displayResource.length) {
+      displayResource.forEach((rs) => {
+        const key = withPrefixRequest ? `requests.${rs.key}` : rs.key;
+        const val = resources[key];
+        if (utils.isValidGPUResourceValue(val)) {
+          lodashEs.set(row, ["resources", utils.sanitizeGPUKey(rs.key) ?? ""], formatNumUnit.formatNumUnit(val));
+        }
+        if (showSide) {
+          const sideVal = sideQuota == null ? void 0 : sideQuota.resources[key];
+          if (utils.isValidGPUResourceValue(sideVal)) {
+            lodashEs.set(sideRow, ["resources", utils.sanitizeGPUKey(rs.key) ?? ""], formatNumUnit.formatNumUnit(sideVal));
+          }
+        }
+      });
+      if (utils.isNvidiaVgpu(type) && isLimitOne) {
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuModel) {
+          Object.assign(row, {
+            [types.nvidiaVgpuModelKey]: vgpu.nvidiaVgpuModel
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuDevices) {
+          Object.assign(row, {
+            [types.nvidiaVgpuDevicesKey]: vgpu.nvidiaVgpuDevices
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuPriority) {
+          Object.assign(row, {
+            [types.nvidiaVgpuPriorityKey]: vgpu.nvidiaVgpuPriority
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuGpuSchedule) {
+          Object.assign(row, {
+            [types.nvidiaVgpuGpuScheduleKey]: vgpu.nvidiaVgpuGpuSchedule
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuNodeSchedule) {
+          Object.assign(row, {
+            [types.nvidiaVgpuNodeScheduleKey]: vgpu.nvidiaVgpuNodeSchedule
+          });
+        }
+      }
+    }
+    if (showSide && !sideRows.includes(sideRow)) {
+      sideRows.push(sideRow);
+    }
+    if (!rows.includes(row)) {
+      rows.push(row);
+    }
+  });
+  return {
+    rows,
+    sideRows
+  };
+};
+exports.buildGpuFormFormattedUpdate = buildGpuFormFormattedUpdate;
+exports.buildGpuFormInitialRows = buildGpuFormInitialRows;
+exports.buildGpuFormSideRow = buildGpuFormSideRow;
+exports.buildGpuFormVgpuUpdateEmits = buildGpuFormVgpuUpdateEmits;
+exports.filterGpuFormRows = filterGpuFormRows;

package/dist/components/gpu/src/gpuForm.mapper.mjs

@@ -0,0 +1,199 @@
+import { set } from "lodash-es";
+import { createEmptyRow, gpuFormRowIdLength } from "./gpuForm.constants.mjs";
+import { nvidiaVgpuModelKey, nvidiaVgpuDevicesKey, nvidiaVgpuPriorityKey, nvidiaVgpuGpuScheduleKey, nvidiaVgpuNodeScheduleKey } from "../types.mjs";
+import { isValidGPUResourceValue, sanitizeGPUKey, isNvidiaVgpu, deSanitizeGPUKey } from "../utils.mjs";
+import { randomStr } from "../../../utils/randomStr.mjs";
+import { formatNumUnit } from "../../../utils/formatNumUnit.mjs";
+const buildGpuFormFormattedUpdate = (rows, existTypes, withPrefixRequest = false) => {
+  const currentVgpuState = {
+    nvidiaVgpuModel: "",
+    nvidiaVgpuPriority: ""
+  };
+  const resources = rows.reduce((pre, row) => {
+    const {
+      type,
+      resources: rest,
+      [nvidiaVgpuModelKey]: nvidiaVgpuModel,
+      [nvidiaVgpuDevicesKey]: nvidiaVgpuDevices,
+      [nvidiaVgpuPriorityKey]: nvidiaVgpuPriority,
+      [nvidiaVgpuGpuScheduleKey]: nvidiaVgpuGpuSchedule,
+      [nvidiaVgpuNodeScheduleKey]: nvidiaVgpuNodeSchedule
+    } = row;
+    const vgpuResource = Object.entries(rest ?? {}).reduce((preRes, [key, val]) => {
+      if (!isValidGPUResourceValue(val)) {
+        return preRes;
+      }
+      const finalResourceKey = deSanitizeGPUKey(key) ?? "";
+      Object.assign(preRes, {
+        [withPrefixRequest ? `requests.${finalResourceKey}` : finalResourceKey]: val
+      });
+      return preRes;
+    }, {});
+    Object.assign(pre, vgpuResource);
+    if (isNvidiaVgpu(type)) {
+      Object.assign(currentVgpuState, {
+        nvidiaVgpuModel,
+        nvidiaVgpuDevices,
+        nvidiaVgpuPriority,
+        nvidiaVgpuGpuSchedule,
+        nvidiaVgpuNodeSchedule
+      });
+    }
+    return pre;
+  }, {});
+  return {
+    change: {
+      types: existTypes,
+      resources
+    },
+    vgpu: currentVgpuState
+  };
+};
+const filterGpuFormRows = (items, gpuOptionsMap) => {
+  const diffRows = items.filter((item) => item.type && gpuOptionsMap.has(item.type));
+  if (!diffRows.length) {
+    return [createEmptyRow()];
+  }
+  return diffRows;
+};
+const buildGpuFormVgpuUpdateEmits = (vgpu, props, vgpuExist) => {
+  var _a;
+  const emits = [];
+  if (props.enableNvidiaVgpuModel && vgpuExist) {
+    emits.push(["update:nvidiaVgpuModel", vgpu.nvidiaVgpuModel]);
+  } else if (props.nvidiaVgpuModel) {
+    emits.push(["update:nvidiaVgpuModel", void 0]);
+  }
+  if (props.enableNvidiaVgpuDevices && vgpuExist) {
+    emits.push(["update:nvidiaVgpuDevices", vgpu.nvidiaVgpuDevices]);
+  } else if ((_a = props.nvidiaVgpuDevices) == null ? void 0 : _a.length) {
+    emits.push(["update:nvidiaVgpuDevices", void 0]);
+  }
+  if (props.enableNvidiaVgpuPriority && vgpuExist) {
+    emits.push(["update:nvidiaVgpuPriority", vgpu.nvidiaVgpuPriority]);
+  } else if (props.nvidiaVgpuPriority) {
+    emits.push(["update:nvidiaVgpuPriority", void 0]);
+  }
+  if (props.enableNvidiaVgpuSchedulePolicy && vgpuExist) {
+    emits.push(["update:nvidiaVgpuGpuSchedule", vgpu.nvidiaVgpuGpuSchedule]);
+    emits.push(["update:nvidiaVgpuNodeSchedule", vgpu.nvidiaVgpuNodeSchedule]);
+  } else if (props.nvidiaVgpuGpuSchedule || props.nvidiaVgpuNodeSchedule) {
+    emits.push(["update:nvidiaVgpuGpuSchedule", void 0]);
+    emits.push(["update:nvidiaVgpuNodeSchedule", void 0]);
+  }
+  return emits;
+};
+const buildGpuFormSideRow = ({
+  row,
+  gpuOptionsMap,
+  sideQuota,
+  withPrefixRequest = false
+}) => {
+  var _a, _b;
+  const sideRow = {
+    ...row,
+    type: (_a = row.type) == null ? void 0 : _a.toString(),
+    resources: {}
+  };
+  const currentGpuSettings = gpuOptionsMap.get(sideRow.type ?? "");
+  (_b = currentGpuSettings == null ? void 0 : currentGpuSettings.resource) == null ? void 0 : _b.forEach(({ key }) => {
+    const actualKey = withPrefixRequest ? `requests.${key}` : key;
+    const val = sideQuota == null ? void 0 : sideQuota.resources[actualKey ?? ""];
+    if (isValidGPUResourceValue(val)) {
+      set(sideRow, ["resources", sanitizeGPUKey(key) ?? ""], formatNumUnit(val));
+    }
+  });
+  return sideRow;
+};
+const buildGpuFormInitialRows = ({
+  quota,
+  availableQuota,
+  sideQuota,
+  gpuOptionsMap,
+  getDisplayResource,
+  withPrefixRequest = false,
+  showSide = false,
+  isLimitOne = false,
+  vgpu
+}) => {
+  const { types, resources } = quota;
+  const { types: availableTypes } = availableQuota ?? {};
+  const newTypes = [.../* @__PURE__ */ new Set([...availableTypes ?? [], ...types])];
+  const rows = [];
+  const sideRows = [];
+  newTypes.forEach((type) => {
+    if (!gpuOptionsMap.has(type)) {
+      return;
+    }
+    const row = {
+      id: randomStr(gpuFormRowIdLength),
+      removable: !(availableTypes == null ? void 0 : availableTypes.includes(type)),
+      type
+    };
+    const sideRow = {
+      type,
+      id: randomStr(gpuFormRowIdLength),
+      resources: {}
+    };
+    const displayResource = getDisplayResource(type);
+    if (displayResource.length) {
+      displayResource.forEach((rs) => {
+        const key = withPrefixRequest ? `requests.${rs.key}` : rs.key;
+        const val = resources[key];
+        if (isValidGPUResourceValue(val)) {
+          set(row, ["resources", sanitizeGPUKey(rs.key) ?? ""], formatNumUnit(val));
+        }
+        if (showSide) {
+          const sideVal = sideQuota == null ? void 0 : sideQuota.resources[key];
+          if (isValidGPUResourceValue(sideVal)) {
+            set(sideRow, ["resources", sanitizeGPUKey(rs.key) ?? ""], formatNumUnit(sideVal));
+          }
+        }
+      });
+      if (isNvidiaVgpu(type) && isLimitOne) {
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuModel) {
+          Object.assign(row, {
+            [nvidiaVgpuModelKey]: vgpu.nvidiaVgpuModel
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuDevices) {
+          Object.assign(row, {
+            [nvidiaVgpuDevicesKey]: vgpu.nvidiaVgpuDevices
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuPriority) {
+          Object.assign(row, {
+            [nvidiaVgpuPriorityKey]: vgpu.nvidiaVgpuPriority
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuGpuSchedule) {
+          Object.assign(row, {
+            [nvidiaVgpuGpuScheduleKey]: vgpu.nvidiaVgpuGpuSchedule
+          });
+        }
+        if (vgpu == null ? void 0 : vgpu.nvidiaVgpuNodeSchedule) {
+          Object.assign(row, {
+            [nvidiaVgpuNodeScheduleKey]: vgpu.nvidiaVgpuNodeSchedule
+          });
+        }
+      }
+    }
+    if (showSide && !sideRows.includes(sideRow)) {
+      sideRows.push(sideRow);
+    }
+    if (!rows.includes(row)) {
+      rows.push(row);
+    }
+  });
+  return {
+    rows,
+    sideRows
+  };
+};
+export {
+  buildGpuFormFormattedUpdate,
+  buildGpuFormInitialRows,
+  buildGpuFormSideRow,
+  buildGpuFormVgpuUpdateEmits,
+  filterGpuFormRows
+};

package/dist/components/gpu/src/gpuFormItem.mapper.d.ts

@@ -0,0 +1,38 @@
+import { type GPUSetting, type GpuUsage, type GpuQuotaItem } from '../types';
+import type { GpuFormOptionsMap } from './gpuForm.internal-types';
+export type GpuFormItemInitialState = {
+    values: GpuQuotaItem;
+    dynamicQuota?: GpuQuotaItem['resources'];
+    openNvidiaAssignGpu: boolean;
+    openNvidiaVgpuSchedulePolicy: boolean;
+};
+export type GpuFormItemAdvancedFeatures = {
+    enableNvidiaVgpuModel?: boolean;
+    enableNvidiaVgpuDevices?: boolean;
+    enableNvidiaVgpuPriority?: boolean;
+    enableNvidiaVgpuSchedulePolicy?: boolean;
+};
+export type GpuFormItemInitialStateParams = {
+    quotaItem: GpuQuotaItem;
+    gpuOptionsMap: GpuFormOptionsMap;
+    advanced: GpuFormItemAdvancedFeatures;
+};
+export type GpuFormItemChangePayloadParams = {
+    quota: GpuQuotaItem;
+    dynamicQuota?: GpuQuotaItem['resources'];
+    quotaItem: GpuQuotaItem;
+    showDynamicForm?: boolean;
+    advanced: Pick<GpuFormItemAdvancedFeatures, 'enableNvidiaVgpuPriority' | 'enableNvidiaVgpuSchedulePolicy'>;
+    openNvidiaAssignGpu?: boolean;
+    openNvidiaVgpuSchedulePolicy?: boolean;
+};
+export type FilterGpuFormItemOptionsParams = {
+    gpuOptionsMap: GpuFormOptionsMap;
+    quotaType?: string;
+    existTypes: string[];
+    targetType?: string;
+};
+export declare function buildGpuFormItemDefaultResources(gpuOption: GPUSetting | undefined, gpuUsage: GpuUsage): GpuQuotaItem['resources'];
+export declare function buildGpuFormItemInitialState({ quotaItem, gpuOptionsMap, advanced, }: GpuFormItemInitialStateParams): GpuFormItemInitialState | undefined;
+export declare function buildGpuFormItemChangePayload({ quota, dynamicQuota, quotaItem, showDynamicForm, advanced, openNvidiaAssignGpu, openNvidiaVgpuSchedulePolicy, }: GpuFormItemChangePayloadParams): GpuQuotaItem;
+export declare function filterGpuFormItemOptions({ gpuOptionsMap, quotaType, existTypes, targetType, }: FilterGpuFormItemOptionsParams): Map<string, GPUSetting>;

package/dist/components/gpu/src/gpuFormItem.mapper.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lodashEs = require("lodash-es");
+const types = require("../types.js");
+const utils = require("../utils.js");
+function buildGpuFormItemDefaultResources(gpuOption, gpuUsage) {
+  var _a;
+  if (gpuUsage !== "workload" || !utils.isHamiGpu(gpuOption == null ? void 0 : gpuOption.provider)) {
+    return {};
+  }
+  const cardResource = (_a = gpuOption == null ? void 0 : gpuOption.resource) == null ? void 0 : _a.find((resource) => {
+    var _a2;
+    return resource.type === "cardNum" && typeof ((_a2 = resource.range) == null ? void 0 : _a2.max) === "number" && resource.range.max > 0;
+  });
+  if (!(cardResource == null ? void 0 : cardResource.key)) {
+    return {};
+  }
+  return {
+    [utils.sanitizeGPUKey(cardResource.key) ?? cardResource.key]: 1
+  };
+}
+function buildGpuFormItemInitialState({
+  quotaItem,
+  gpuOptionsMap,
+  advanced
+}) {
+  var _a;
+  const { id, type, resources } = quotaItem;
+  if (!id) {
+    return void 0;
+  }
+  const values = {
+    id,
+    type
+  };
+  let dynamicQuota;
+  let openNvidiaAssignGpu = false;
+  let openNvidiaVgpuSchedulePolicy = false;
+  const isDynamic = type && ((_a = gpuOptionsMap.get(type)) == null ? void 0 : _a.isDynamic);
+  if (isDynamic) {
+    dynamicQuota = utils.deSanitizeGPUObjectKey(resources);
+  } else {
+    Object.entries(resources ?? {}).forEach(([key, val]) => {
+      lodashEs.set(values, ["resources", key], val);
+    });
+  }
+  const isVgpu = utils.isNvidiaVgpu(type ?? "");
+  if (isVgpu && (advanced.enableNvidiaVgpuModel || advanced.enableNvidiaVgpuDevices)) {
+    const devices = quotaItem[types.nvidiaVgpuDevicesKey];
+    const model = quotaItem[types.nvidiaVgpuModelKey];
+    const hasDevices = !!(devices == null ? void 0 : devices.length);
+    const hasModel = !!model;
+    openNvidiaAssignGpu = !!(hasDevices || hasModel);
+    if (openNvidiaAssignGpu) {
+      if (hasModel) {
+        values[types.nvidiaVgpuModelKey] = model;
+      } else if (hasDevices) {
+        values[types.nvidiaVgpuDevicesKey] = devices;
+      }
+    }
+  }
+  if (isVgpu && advanced.enableNvidiaVgpuSchedulePolicy) {
+    const gpuSchedule = quotaItem[types.nvidiaVgpuGpuScheduleKey];
+    const nodeSchedule = quotaItem[types.nvidiaVgpuNodeScheduleKey];
+    openNvidiaVgpuSchedulePolicy = !!gpuSchedule || !!nodeSchedule;
+    if (openNvidiaVgpuSchedulePolicy) {
+      values[types.nvidiaVgpuGpuScheduleKey] = gpuSchedule;
+      values[types.nvidiaVgpuNodeScheduleKey] = nodeSchedule;
+    }
+  }
+  if (advanced.enableNvidiaVgpuPriority) {
+    values[types.nvidiaVgpuPriorityKey] = quotaItem[types.nvidiaVgpuPriorityKey];
+  }
+  return {
+    values,
+    dynamicQuota,
+    openNvidiaAssignGpu,
+    openNvidiaVgpuSchedulePolicy
+  };
+}
+function buildGpuFormItemChangePayload({
+  quota,
+  dynamicQuota,
+  quotaItem,
+  showDynamicForm,
+  advanced,
+  openNvidiaAssignGpu,
+  openNvidiaVgpuSchedulePolicy
+}) {
+  if (showDynamicForm) {
+    return {
+      type: quota.type,
+      id: quota.id,
+      resources: dynamicQuota,
+      removable: quotaItem.removable
+    };
+  }
+  const validResources = Object.fromEntries(
+    Object.entries(quota.resources ?? {}).filter(([, value]) => utils.isValidGPUResourceValue(value))
+  );
+  const newQuota = {
+    type: quota.type,
+    id: quota.id,
+    resources: utils.deSanitizeGPUObjectKey(validResources),
+    removable: quotaItem.removable
+  };
+  if (utils.isNvidiaVgpu(quota.type)) {
+    if (openNvidiaAssignGpu) {
+      const devices = quota[types.nvidiaVgpuDevicesKey];
+      const model = quota[types.nvidiaVgpuModelKey];
+      if (model) {
+        newQuota[types.nvidiaVgpuModelKey] = model;
+      } else if (devices == null ? void 0 : devices.length) {
+        newQuota[types.nvidiaVgpuDevicesKey] = devices;
+      }
+    }
+    if (advanced.enableNvidiaVgpuPriority) {
+      newQuota[types.nvidiaVgpuPriorityKey] = quota[types.nvidiaVgpuPriorityKey];
+    }
+    if (advanced.enableNvidiaVgpuSchedulePolicy) {
+      if (openNvidiaVgpuSchedulePolicy) {
+        Object.assign(newQuota, {
+          [types.nvidiaVgpuGpuScheduleKey]: quota[types.nvidiaVgpuGpuScheduleKey],
+          [types.nvidiaVgpuNodeScheduleKey]: quota[types.nvidiaVgpuNodeScheduleKey]
+        });
+      } else {
+        Object.assign(newQuota, {
+          [types.nvidiaVgpuGpuScheduleKey]: void 0,
+          [types.nvidiaVgpuNodeScheduleKey]: void 0
+        });
+      }
+    }
+  }
+  return newQuota;
+}
+function filterGpuFormItemOptions({
+  gpuOptionsMap,
+  quotaType,
+  existTypes,
+  targetType
+}) {
+  const map = /* @__PURE__ */ new Map();
+  gpuOptionsMap.forEach((option, key) => {
+    if (key === quotaType || !existTypes.includes(key) && (!targetType || targetType && key === targetType)) {
+      map.set(key, option);
+    }
+  });
+  return map;
+}
+exports.buildGpuFormItemChangePayload = buildGpuFormItemChangePayload;
+exports.buildGpuFormItemDefaultResources = buildGpuFormItemDefaultResources;
+exports.buildGpuFormItemInitialState = buildGpuFormItemInitialState;
+exports.filterGpuFormItemOptions = filterGpuFormItemOptions;