@dao-style/biz 0.6.0 → 0.7.0

package/dist/components/gpu/src/{GpuFormItem.vue.mjs → components/GpuFormItem.vue.mjs}

@@ -1,6 +1,6 @@
 import _sfc_main from "./GpuFormItem.vue2.mjs";
-import { resolveComponent, openBlock, createBlock, withCtx, createVNode, createSlots, createElementVNode, createElementBlock, Fragment, renderList, createTextVNode, toDisplayString, createCommentVNode, renderSlot, normalizeProps, guardReactiveProps } from "vue";
-import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import { resolveComponent, openBlock, createBlock, withCtx, createVNode, createSlots, createElementVNode, createElementBlock, Fragment, renderList, createTextVNode, toDisplayString, createCommentVNode, renderSlot, normalizeProps, guardReactiveProps, mergeProps } from "vue";
+import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.mjs";
 const _hoisted_1 = { class: "gpu-quotas-item__type-select-wrap" };
 const _hoisted_2 = { key: 0 };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
@@ -9,7 +9,6 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_dao_select = resolveComponent("dao-select");
   const _component_dao_action_icon = resolveComponent("dao-action-icon");
   const _component_dao_history_link = resolveComponent("dao-history-link");
-  const _component_dao_message = resolveComponent("dao-message");
   const _component_dao_helper_text = resolveComponent("dao-helper-text");
   const _component_dao_form_item_validate = resolveComponent("dao-form-item-validate");
   const _component_gpu_form_dynamic_item = resolveComponent("gpu-form-dynamic-item");
@@ -91,20 +90,12 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
             })
           ]),
           key: "0"
-        } : _ctx.isNvidiaVgpu(_ctx.quota.type) && !_ctx.isSide ? {
+        } : _ctx.isShowHamiGpuHelper ? {
           name: "helper",
           fn: withCtx(() => [
             createVNode(_component_dao_helper_text, null, {
               default: withCtx(() => [
-                createVNode(_component_dao_message, {
-                  simple: "",
-                  type: "info"
-                }, {
-                  default: withCtx(() => [
-                    createTextVNode(toDisplayString(_ctx.$t("biz.components.Gpu.hashrateTip")), 1)
-                  ]),
-                  _: 1
-                })
+                createTextVNode(toDisplayString(_ctx.$t("biz.components.Gpu.hashrateTip")), 1)
               ]),
               _: 1
             })
@@ -158,7 +149,9 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
           "available-quota-item": _ctx.availableQuotaItem,
           "is-side": _ctx.isSide,
           "enable-range-validate": _ctx.enableRangeValidate,
-          "quota-item": _ctx.quotaItem
+          "quota-item": _ctx.quotaItem,
+          "gpu-provider": _ctx.currentGpuProvider,
+          "gpu-usage": _ctx.gpuUsage
         }, createSlots({ _: 2 }, [
           renderList(_ctx.gpuResourceHelperSlot, (resourceKey) => {
             return {
@@ -168,21 +161,24 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               ])
             };
           })
-        ]), 1032, ["resources", "quota", "used-quota-item", "available-quota-item", "is-side", "enable-range-validate", "quota-item"])),
-        createVNode(_component_gpu_advanced_form, {
+        ]), 1032, ["resources", "quota", "used-quota-item", "available-quota-item", "is-side", "enable-range-validate", "quota-item", "gpu-provider", "gpu-usage"])),
+        createVNode(_component_gpu_advanced_form, mergeProps({
           "open-nvidia-vgpu-model": _ctx.openNvidiaVgpuModel,
           "onUpdate:openNvidiaVgpuModel": _cache[2] || (_cache[2] = ($event) => _ctx.openNvidiaVgpuModel = $event),
-          "open-nvidia-vgpu-scheule-policy": _ctx.openNvidiaVgpuScheulePolicy,
-          "onUpdate:openNvidiaVgpuScheulePolicy": _cache[3] || (_cache[3] = ($event) => _ctx.openNvidiaVgpuScheulePolicy = $event),
-          quota: _ctx.quota,
-          "enable-remote-call": _ctx.enableRemoteCall,
-          "enable-nvidia-vgpu-model": _ctx.enableNvidiaVgpuModel,
-          "enable-nvidia-vgpu-priority": _ctx.enableNvidiaVgpuPriority,
-          "enable-nvidia-vgpu-schedule-policy": _ctx.enableNvidiaVgpuSchedulePolicy,
-          "nvidia-gpu-models": _ctx.nvidiaGpuModels,
-          "nvidia-vgpu-models-adaptor": _ctx.nvidiaVgpuModelsAdaptor,
-          "is-side": _ctx.isSide
-        }, null, 8, ["open-nvidia-vgpu-model", "open-nvidia-vgpu-scheule-policy", "quota", "enable-remote-call", "enable-nvidia-vgpu-model", "enable-nvidia-vgpu-priority", "enable-nvidia-vgpu-schedule-policy", "nvidia-gpu-models", "nvidia-vgpu-models-adaptor", "is-side"])
+          "open-nvidia-assign-gpu": _ctx.openNvidiaAssignGpu,
+          "onUpdate:openNvidiaAssignGpu": _cache[3] || (_cache[3] = ($event) => _ctx.openNvidiaAssignGpu = $event),
+          "open-nvidia-vgpu-schedule-policy": _ctx.openNvidiaVgpuSchedulePolicy,
+          "onUpdate:openNvidiaVgpuSchedulePolicy": _cache[4] || (_cache[4] = ($event) => _ctx.openNvidiaVgpuSchedulePolicy = $event),
+          quota: _ctx.quotaItem
+        }, _ctx.gpuAdvancedFormProps), createSlots({ _: 2 }, [
+          _ctx.$slots["assign-gpu-disabled-message"] ? {
+            name: "assign-gpu-disabled-message",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "assign-gpu-disabled-message")
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1040, ["open-nvidia-vgpu-model", "open-nvidia-assign-gpu", "open-nvidia-vgpu-schedule-policy", "quota"])
       ], 64))
     ]),
     _: 3

package/dist/components/gpu/src/components/GpuFormItem.vue2.js

@@ -0,0 +1,61 @@
+"use strict";
+const vue = require("vue");
+const yup = require("yup");
+const vueI18n = require("vue-i18n");
+const extend = require("@dao-style/extend");
+const props = require("../../props.js");
+const types = require("../../types.js");
+const GpuResources = require("./GpuResources.vue.js");
+const GpuAdvancedForm = require("./GpuAdvancedForm.vue.js");
+const utils = require("../../utils.js");
+const GpuFormDynamicItem = require("./GpuFormDynamicItem.vue.js");
+const useGpuFormItemState = require("../useGpuFormItemState.js");
+require("../../style/gpu-form-item.scss.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const yup__namespace = /* @__PURE__ */ _interopNamespaceDefault(yup);
+const _sfc_main = vue.defineComponent({
+  name: "DaoGpuFormItem",
+  components: {
+    GpuFormDynamicItem,
+    DaoFormItemValidate: extend.DaoFormItemValidate,
+    GpuResources,
+    GpuAdvancedForm,
+    DaoHistoryLink: extend.DaoHistoryLink
+  },
+  props: props.gpuFormItemProps,
+  emits: [
+    "change",
+    "refreshGpuOptionsMap"
+  ],
+  setup(props2, {
+    emit: emits,
+    slots
+  }) {
+    const i18nInstance = vueI18n.useI18n();
+    const state = useGpuFormItemState.useGpuFormItemState(props2, emits, slots, i18nInstance);
+    return {
+      ...state,
+      nvidiaVgpuModelKey: types.nvidiaVgpuModelKey,
+      nvidiaVgpuPriorityKey: types.nvidiaVgpuPriorityKey,
+      yup: yup__namespace,
+      isNvidiaVgpu: utils.isNvidiaVgpu,
+      isNvidiaMig: utils.isNvidiaMig
+    };
+  }
+});
+module.exports = _sfc_main;

package/dist/components/gpu/src/components/GpuFormItem.vue2.mjs

@@ -0,0 +1,45 @@
+import { defineComponent } from "vue";
+import * as yup from "yup";
+import { useI18n } from "vue-i18n";
+import { DaoFormItemValidate, DaoHistoryLink } from "@dao-style/extend";
+import { gpuFormItemProps } from "../../props.mjs";
+import { nvidiaVgpuModelKey, nvidiaVgpuPriorityKey } from "../../types.mjs";
+import GpuResources from "./GpuResources.vue.mjs";
+import GpuAdvancedForm from "./GpuAdvancedForm.vue.mjs";
+import { isNvidiaVgpu, isNvidiaMig } from "../../utils.mjs";
+import GpuFormDynamicItem from "./GpuFormDynamicItem.vue.mjs";
+import { useGpuFormItemState } from "../useGpuFormItemState.mjs";
+import "../../style/gpu-form-item.scss.mjs";
+const _sfc_main = defineComponent({
+  name: "DaoGpuFormItem",
+  components: {
+    GpuFormDynamicItem,
+    DaoFormItemValidate,
+    GpuResources,
+    GpuAdvancedForm,
+    DaoHistoryLink
+  },
+  props: gpuFormItemProps,
+  emits: [
+    "change",
+    "refreshGpuOptionsMap"
+  ],
+  setup(props, {
+    emit: emits,
+    slots
+  }) {
+    const i18nInstance = useI18n();
+    const state = useGpuFormItemState(props, emits, slots, i18nInstance);
+    return {
+      ...state,
+      nvidiaVgpuModelKey,
+      nvidiaVgpuPriorityKey,
+      yup,
+      isNvidiaVgpu,
+      isNvidiaMig
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/gpu/src/{GpuResources.vue.d.ts → components/GpuResources.vue.d.ts}

@@ -1,11 +1,11 @@
 import * as yup from 'yup';
-import { GPUResourceSetting } from '../types';
+import { GPUResourceSetting } from '../../types';
 declare const _default: import("vue").DefineComponent<{
     quota: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
     };
     quotaItem: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
         default: () => {};
     };
     isSide: {
@@ -16,40 +16,50 @@ declare const _default: import("vue").DefineComponent<{
         type: import("vue").PropType<GPUResourceSetting[]>;
         required: boolean;
     };
+    gpuProvider: {
+        type: StringConstructor;
+        default: string;
+    };
     enableRangeValidate: {
         type: BooleanConstructor;
         default: boolean;
     };
     availableQuotaItem: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
         default: undefined;
     };
     usedQuotaItem: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
         default: undefined;
     };
+    gpuUsage: {
+        type: import("vue").PropType<import("../../types").GpuUsage>;
+        default: string;
+    };
 }, {
     getIsIluvatarMemory: (alias?: string) => boolean | undefined;
-    getIsNvidiaVgpuMemoryMb: (alias?: string) => boolean | undefined;
+    isVgpuMemoryResource: (resource: GPUResourceSetting) => boolean | undefined;
     getResHelper: (available: GPUResourceSetting['available'], key?: string, alias?: string) => string;
-    getResUnit: (res: GPUResourceSetting) => string | undefined;
+    getSideResUnit: (resource: GPUResourceSetting) => string | undefined;
     resourcePlaceholder: import("vue").ComputedRef<string>;
     getResRequired: (resource: GPUResourceSetting) => boolean;
-    nvidiaVgpuResOrder: Map<string, string>;
-    nvidiaVgpuMemory: import("vue").WritableComputedRef<number | undefined>;
+    nvidiaVgpuMemory: import("vue").WritableComputedRef<string | number | undefined>;
+    vgpuMemoryUnits: readonly ["Gi", "Mi"];
+    nvidiaVgpuMemoryUnit: import("vue").WritableComputedRef<"Gi" | "Mi">;
     sanitizeGPUKey: (key?: string | undefined) => string | undefined;
+    getResLabel: (resource: GPUResourceSetting) => string;
+    getResIconMessage: (resource: GPUResourceSetting) => string;
+    isHamiQuota: import("vue").ComputedRef<boolean>;
     yup: typeof yup;
     getResourceYup: (resource: GPUResourceSetting) => yup.default<number | undefined, import("yup/lib/types").AnyObject, number | undefined>;
     getNvidiaVgpuMemoryResourceYup: (resource: GPUResourceSetting) => yup.default<number | undefined, import("yup/lib/types").AnyObject, number | undefined>;
-    nvidiaVgpuMemoryResource: import("vue").ComputedRef<GPUResourceSetting | undefined>;
-    nvidiaVgpuMemoryField: import("vue").ComputedRef<string>;
     getSideValue: (resource: GPUResourceSetting) => string | number;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     quota: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
     };
     quotaItem: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
         default: () => {};
     };
     isSide: {
@@ -60,23 +70,33 @@ declare const _default: import("vue").DefineComponent<{
         type: import("vue").PropType<GPUResourceSetting[]>;
         required: boolean;
     };
+    gpuProvider: {
+        type: StringConstructor;
+        default: string;
+    };
     enableRangeValidate: {
         type: BooleanConstructor;
         default: boolean;
     };
     availableQuotaItem: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
         default: undefined;
     };
     usedQuotaItem: {
-        type: import("vue").PropType<import("../types").GpuQuotaItem>;
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
         default: undefined;
     };
+    gpuUsage: {
+        type: import("vue").PropType<import("../../types").GpuUsage>;
+        default: string;
+    };
 }>>, {
+    gpuUsage: import("../../types").GpuUsage;
     enableRangeValidate: boolean;
-    quotaItem: import("../types").GpuQuotaItem;
+    quotaItem: import("../../types").GpuQuotaItem;
     isSide: boolean;
-    availableQuotaItem: import("../types").GpuQuotaItem;
-    usedQuotaItem: import("../types").GpuQuotaItem;
+    gpuProvider: string;
+    availableQuotaItem: import("../../types").GpuQuotaItem;
+    usedQuotaItem: import("../../types").GpuQuotaItem;
 }>;
 export default _default;

package/dist/components/gpu/src/components/GpuResources.vue.js

@@ -0,0 +1,153 @@
+"use strict";
+const GpuResources_vue_vue_type_script_lang = require("./GpuResources.vue2.js");
+const vue = require("vue");
+const _pluginVue_exportHelper = require("../../../../_virtual/_plugin-vue_export-helper.js");
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_dao_icon = vue.resolveComponent("dao-icon");
+  const _component_dao_input = vue.resolveComponent("dao-input");
+  const _component_dao_option = vue.resolveComponent("dao-option");
+  const _component_dao_select = vue.resolveComponent("dao-select");
+  const _component_dao_form_item_validate = vue.resolveComponent("dao-form-item-validate");
+  const _component_dao_form_item = vue.resolveComponent("dao-form-item");
+  return vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.resources, (res) => {
+    return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+      key: res.key
+    }, [
+      !(_ctx.isHamiQuota && res.type === "cardNum") ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+        !_ctx.isSide ? (vue.openBlock(), vue.createBlock(_component_dao_form_item_validate, {
+          key: 0,
+          label: _ctx.getResLabel(res),
+          class: vue.normalizeClass(res.unit || _ctx.isVgpuMemoryResource(res) ? "" : "input-without-append"),
+          name: `resources.${_ctx.sanitizeGPUKey(res.key)}`,
+          "control-props": {
+            type: "number",
+            append: res.unit,
+            placeholder: _ctx.resourcePlaceholder
+          },
+          helper: _ctx.getResHelper(res.available, res.key, res.alias),
+          "icon-message": _ctx.getResIconMessage(res),
+          "yup-type": _ctx.yup.number(),
+          "yup-concat": _ctx.isVgpuMemoryResource(res) ? _ctx.getNvidiaVgpuMemoryResourceYup(res) : _ctx.getResourceYup(res),
+          required: _ctx.getResRequired(res)
+        }, vue.createSlots({ _: 2 }, [
+          _ctx.getIsIluvatarMemory(res.alias) ? {
+            name: "control-content",
+            fn: vue.withCtx(({ value, status }) => [
+              vue.createVNode(_component_dao_input, {
+                modelValue: value.value,
+                "onUpdate:modelValue": ($event) => value.value = $event,
+                modelModifiers: { number: true },
+                type: "number",
+                "root-attrs": {
+                  class: "gpu-quotas-item__iluvatar-memory-input"
+                },
+                append: "MB",
+                status,
+                placeholder: _ctx.resourcePlaceholder
+              }, {
+                prefix: vue.withCtx(() => [
+                  vue.createTextVNode(" 256 "),
+                  vue.createVNode(_component_dao_icon, { name: "icon-asterisk" })
+                ]),
+                _: 2
+              }, 1032, ["modelValue", "onUpdate:modelValue", "status", "placeholder"])
+            ]),
+            key: "0"
+          } : _ctx.isVgpuMemoryResource(res) ? {
+            name: "control-content",
+            fn: vue.withCtx(({ status }) => [
+              vue.createVNode(_component_dao_input, {
+                modelValue: _ctx.nvidiaVgpuMemory,
+                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.nvidiaVgpuMemory = $event),
+                modelModifiers: { number: true },
+                type: "number",
+                min: "1",
+                step: "1",
+                block: "",
+                "root-attrs": {
+                  class: "gpu-quotas-item__vgpu-memory-input"
+                },
+                status,
+                placeholder: _ctx.resourcePlaceholder
+              }, {
+                append: vue.withCtx(() => [
+                  vue.createVNode(_component_dao_select, {
+                    modelValue: _ctx.nvidiaVgpuMemoryUnit,
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.nvidiaVgpuMemoryUnit = $event),
+                    class: "gpu-quotas-item__vgpu-memory-unit"
+                  }, {
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.vgpuMemoryUnits, (unit) => {
+                        return vue.openBlock(), vue.createBlock(_component_dao_option, {
+                          key: unit,
+                          value: unit
+                        }, null, 8, ["value"]);
+                      }), 128))
+                    ]),
+                    _: 1
+                  }, 8, ["modelValue"])
+                ]),
+                _: 2
+              }, 1032, ["modelValue", "status", "placeholder"])
+            ]),
+            key: "1"
+          } : void 0,
+          _ctx.$slots[`helper-${res.key}`] ? {
+            name: "helper",
+            fn: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, `helper-${res.key}`, {
+                resource: res,
+                quota: _ctx.quota,
+                isSide: _ctx.isSide,
+                gpuOptions: _ctx.resources
+              })
+            ]),
+            key: "2"
+          } : void 0
+        ]), 1032, ["label", "class", "name", "control-props", "helper", "icon-message", "yup-type", "yup-concat", "required"])) : (vue.openBlock(), vue.createBlock(_component_dao_form_item, {
+          key: 1,
+          label: _ctx.getResLabel(res),
+          class: vue.normalizeClass(res.unit || _ctx.isVgpuMemoryResource(res) ? "" : "input-without-append")
+        }, vue.createSlots({
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_dao_input, {
+              "model-value": _ctx.getSideValue(res),
+              type: "number",
+              disabled: "",
+              "root-attrs": {
+                class: _ctx.getIsIluvatarMemory(res.alias) && "gpu-quotas-item__iluvatar-memory-input"
+              },
+              append: _ctx.getSideResUnit(res),
+              placeholder: _ctx.resourcePlaceholder
+            }, vue.createSlots({ _: 2 }, [
+              _ctx.getIsIluvatarMemory(res.alias) ? {
+                name: "prefix",
+                fn: vue.withCtx(() => [
+                  vue.createTextVNode(" 256 "),
+                  vue.createVNode(_component_dao_icon, { name: "icon-asterisk" })
+                ]),
+                key: "0"
+              } : void 0
+            ]), 1032, ["model-value", "root-attrs", "append", "placeholder"])
+          ]),
+          _: 2
+        }, [
+          _ctx.$slots[`helper-${res.key}`] ? {
+            name: "helper",
+            fn: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, `helper-${res.key}`, {
+                resource: res,
+                quota: _ctx.quota,
+                isSide: _ctx.isSide,
+                gpuOptions: _ctx.resources
+              })
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["label", "class"]))
+      ], 64)) : vue.createCommentVNode("", true)
+    ], 64);
+  }), 128);
+}
+const GpuResources = /* @__PURE__ */ _pluginVue_exportHelper(GpuResources_vue_vue_type_script_lang, [["render", _sfc_render]]);
+module.exports = GpuResources;

package/dist/components/gpu/src/components/GpuResources.vue.mjs

@@ -0,0 +1,154 @@
+import _sfc_main from "./GpuResources.vue2.mjs";
+import { resolveComponent, openBlock, createElementBlock, Fragment, renderList, createBlock, normalizeClass, createSlots, withCtx, createVNode, createTextVNode, renderSlot, createCommentVNode } from "vue";
+import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.mjs";
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_dao_icon = resolveComponent("dao-icon");
+  const _component_dao_input = resolveComponent("dao-input");
+  const _component_dao_option = resolveComponent("dao-option");
+  const _component_dao_select = resolveComponent("dao-select");
+  const _component_dao_form_item_validate = resolveComponent("dao-form-item-validate");
+  const _component_dao_form_item = resolveComponent("dao-form-item");
+  return openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.resources, (res) => {
+    return openBlock(), createElementBlock(Fragment, {
+      key: res.key
+    }, [
+      !(_ctx.isHamiQuota && res.type === "cardNum") ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+        !_ctx.isSide ? (openBlock(), createBlock(_component_dao_form_item_validate, {
+          key: 0,
+          label: _ctx.getResLabel(res),
+          class: normalizeClass(res.unit || _ctx.isVgpuMemoryResource(res) ? "" : "input-without-append"),
+          name: `resources.${_ctx.sanitizeGPUKey(res.key)}`,
+          "control-props": {
+            type: "number",
+            append: res.unit,
+            placeholder: _ctx.resourcePlaceholder
+          },
+          helper: _ctx.getResHelper(res.available, res.key, res.alias),
+          "icon-message": _ctx.getResIconMessage(res),
+          "yup-type": _ctx.yup.number(),
+          "yup-concat": _ctx.isVgpuMemoryResource(res) ? _ctx.getNvidiaVgpuMemoryResourceYup(res) : _ctx.getResourceYup(res),
+          required: _ctx.getResRequired(res)
+        }, createSlots({ _: 2 }, [
+          _ctx.getIsIluvatarMemory(res.alias) ? {
+            name: "control-content",
+            fn: withCtx(({ value, status }) => [
+              createVNode(_component_dao_input, {
+                modelValue: value.value,
+                "onUpdate:modelValue": ($event) => value.value = $event,
+                modelModifiers: { number: true },
+                type: "number",
+                "root-attrs": {
+                  class: "gpu-quotas-item__iluvatar-memory-input"
+                },
+                append: "MB",
+                status,
+                placeholder: _ctx.resourcePlaceholder
+              }, {
+                prefix: withCtx(() => [
+                  createTextVNode(" 256 "),
+                  createVNode(_component_dao_icon, { name: "icon-asterisk" })
+                ]),
+                _: 2
+              }, 1032, ["modelValue", "onUpdate:modelValue", "status", "placeholder"])
+            ]),
+            key: "0"
+          } : _ctx.isVgpuMemoryResource(res) ? {
+            name: "control-content",
+            fn: withCtx(({ status }) => [
+              createVNode(_component_dao_input, {
+                modelValue: _ctx.nvidiaVgpuMemory,
+                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.nvidiaVgpuMemory = $event),
+                modelModifiers: { number: true },
+                type: "number",
+                min: "1",
+                step: "1",
+                block: "",
+                "root-attrs": {
+                  class: "gpu-quotas-item__vgpu-memory-input"
+                },
+                status,
+                placeholder: _ctx.resourcePlaceholder
+              }, {
+                append: withCtx(() => [
+                  createVNode(_component_dao_select, {
+                    modelValue: _ctx.nvidiaVgpuMemoryUnit,
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.nvidiaVgpuMemoryUnit = $event),
+                    class: "gpu-quotas-item__vgpu-memory-unit"
+                  }, {
+                    default: withCtx(() => [
+                      (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.vgpuMemoryUnits, (unit) => {
+                        return openBlock(), createBlock(_component_dao_option, {
+                          key: unit,
+                          value: unit
+                        }, null, 8, ["value"]);
+                      }), 128))
+                    ]),
+                    _: 1
+                  }, 8, ["modelValue"])
+                ]),
+                _: 2
+              }, 1032, ["modelValue", "status", "placeholder"])
+            ]),
+            key: "1"
+          } : void 0,
+          _ctx.$slots[`helper-${res.key}`] ? {
+            name: "helper",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, `helper-${res.key}`, {
+                resource: res,
+                quota: _ctx.quota,
+                isSide: _ctx.isSide,
+                gpuOptions: _ctx.resources
+              })
+            ]),
+            key: "2"
+          } : void 0
+        ]), 1032, ["label", "class", "name", "control-props", "helper", "icon-message", "yup-type", "yup-concat", "required"])) : (openBlock(), createBlock(_component_dao_form_item, {
+          key: 1,
+          label: _ctx.getResLabel(res),
+          class: normalizeClass(res.unit || _ctx.isVgpuMemoryResource(res) ? "" : "input-without-append")
+        }, createSlots({
+          default: withCtx(() => [
+            createVNode(_component_dao_input, {
+              "model-value": _ctx.getSideValue(res),
+              type: "number",
+              disabled: "",
+              "root-attrs": {
+                class: _ctx.getIsIluvatarMemory(res.alias) && "gpu-quotas-item__iluvatar-memory-input"
+              },
+              append: _ctx.getSideResUnit(res),
+              placeholder: _ctx.resourcePlaceholder
+            }, createSlots({ _: 2 }, [
+              _ctx.getIsIluvatarMemory(res.alias) ? {
+                name: "prefix",
+                fn: withCtx(() => [
+                  createTextVNode(" 256 "),
+                  createVNode(_component_dao_icon, { name: "icon-asterisk" })
+                ]),
+                key: "0"
+              } : void 0
+            ]), 1032, ["model-value", "root-attrs", "append", "placeholder"])
+          ]),
+          _: 2
+        }, [
+          _ctx.$slots[`helper-${res.key}`] ? {
+            name: "helper",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, `helper-${res.key}`, {
+                resource: res,
+                quota: _ctx.quota,
+                isSide: _ctx.isSide,
+                gpuOptions: _ctx.resources
+              })
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1032, ["label", "class"]))
+      ], 64)) : createCommentVNode("", true)
+    ], 64);
+  }), 128);
+}
+const GpuResources = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  GpuResources as default
+};