@dao-style/biz 0.6.0 → 0.7.0

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

@@ -9,6 +9,8 @@ const _hoisted_2 = {
 };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_dao_switch = vue.resolveComponent("dao-switch");
+  const _component_dao_history_link = vue.resolveComponent("dao-history-link");
+  const _component_dao_message = vue.resolveComponent("dao-message");
   const _component_gpu_form_item = vue.resolveComponent("gpu-form-item");
   const _component_dao_action_icon = vue.resolveComponent("dao-action-icon");
   const _component_dao_text_button = vue.resolveComponent("dao-text-button");
@@ -31,6 +33,27 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
           class: "dao-gpu-form__item"
         }, [
           vue.createElementVNode("div", _hoisted_1, [
+            index === 0 && _ctx.gpuUsage === "workload" && _ctx.availableQuotaLink ? (vue.openBlock(), vue.createBlock(_component_dao_message, {
+              key: 0,
+              class: "dao-gpu-form__available-quota-message",
+              type: "info",
+              simple: ""
+            }, {
+              default: vue.withCtx(() => [
+                vue.createVNode(_component_dao_history_link, {
+                  type: "action",
+                  target: "_blank",
+                  "icon-right": "icon-new-tab",
+                  href: _ctx.availableQuotaLink
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(vue.toDisplayString(_ctx.$t("biz.components.Gpu.viewNamespaceAvailableQuota")), 1)
+                  ]),
+                  _: 1
+                }, 8, ["href"])
+              ]),
+              _: 1
+            })) : vue.createCommentVNode("", true),
             vue.createVNode(_component_gpu_form_item, vue.mergeProps({
               ref_for: true,
               ref: ($e) => _ctx.rowsRef[index] = $e,
@@ -38,19 +61,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               "exist-types": _ctx.existTypes,
               "used-quota-item": _ctx.getUsedQuotaItem(index),
               "available-quota-item": _ctx.getAvailableQuotaItem(index)
-            }, {
-              targetType: _ctx.targetType,
-              enableRemoteCall: _ctx.enableRemoteCall,
-              enableRangeValidate: _ctx.enableRangeValidate,
-              enableNvidiaVgpuModel: _ctx.enableNvidiaVgpuModel,
-              enableNvidiaVgpuPriority: _ctx.enableNvidiaVgpuPriority,
-              enableNvidiaVgpuSchedulePolicy: _ctx.enableNvidiaVgpuSchedulePolicy,
-              dynamicLimitOne: _ctx.dynamicLimitOne,
-              gpuOptionsMap: _ctx.gpuOptionsMap,
-              getDisplayResource: _ctx.getDisplayResource,
-              nvidiaGpuModels: _ctx.nvidiaGpuModels,
-              gpuSettingsAdaptor: _ctx.gpuSettingsAdaptor
-            }, {
+            }, _ctx.gpuFormItemProps, {
               onChange: ($e) => _ctx.handleRowChange(index, $e),
               onRefreshGpuOptionsMap: _ctx.fetchGpuOptions
             }), vue.createSlots({ _: 2 }, [
@@ -77,17 +88,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               "quota-item": _ctx.sideRows[index],
               "exist-types": _ctx.existTypes,
               "is-side": ""
-            }, {
-              targetType: _ctx.targetType,
-              enableRemoteCall: _ctx.enableRemoteCall,
-              enableRangeValidate: _ctx.enableRangeValidate,
-              enableNvidiaVgpuModel: _ctx.enableNvidiaVgpuModel,
-              enableNvidiaVgpuPriority: _ctx.enableNvidiaVgpuPriority,
-              gpuOptionsMap: _ctx.gpuOptionsMap,
-              getDisplayResource: _ctx.getDisplayResource,
-              nvidiaGpuModels: _ctx.nvidiaGpuModels,
-              gpuSettingsAdaptor: _ctx.gpuSettingsAdaptor
-            }), vue.createSlots({ _: 2 }, [
+            }, _ctx.sideGpuFormItemProps), vue.createSlots({ _: 2 }, [
               vue.renderList(_ctx.$slots, (slotValue, slotName) => {
                 return {
                   name: slotName,

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

@@ -1,5 +1,5 @@
 import _sfc_main from "./GpuForm.vue2.mjs";
-import { resolveComponent, openBlock, createElementBlock, Fragment, createBlock, createCommentVNode, renderSlot, normalizeProps, guardReactiveProps, createElementVNode, normalizeClass, renderList, createVNode, mergeProps, createSlots, withCtx, createTextVNode, toDisplayString } from "vue";
+import { resolveComponent, openBlock, createElementBlock, Fragment, createBlock, createCommentVNode, renderSlot, normalizeProps, guardReactiveProps, createElementVNode, normalizeClass, renderList, withCtx, createVNode, createTextVNode, toDisplayString, mergeProps, createSlots } from "vue";
 import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
 const _hoisted_1 = { class: "solid-wrapper dao-gpu-form__item--primary" };
 const _hoisted_2 = {
@@ -8,6 +8,8 @@ const _hoisted_2 = {
 };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_dao_switch = resolveComponent("dao-switch");
+  const _component_dao_history_link = resolveComponent("dao-history-link");
+  const _component_dao_message = resolveComponent("dao-message");
   const _component_gpu_form_item = resolveComponent("gpu-form-item");
   const _component_dao_action_icon = resolveComponent("dao-action-icon");
   const _component_dao_text_button = resolveComponent("dao-text-button");
@@ -30,6 +32,27 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
           class: "dao-gpu-form__item"
         }, [
           createElementVNode("div", _hoisted_1, [
+            index === 0 && _ctx.gpuUsage === "workload" && _ctx.availableQuotaLink ? (openBlock(), createBlock(_component_dao_message, {
+              key: 0,
+              class: "dao-gpu-form__available-quota-message",
+              type: "info",
+              simple: ""
+            }, {
+              default: withCtx(() => [
+                createVNode(_component_dao_history_link, {
+                  type: "action",
+                  target: "_blank",
+                  "icon-right": "icon-new-tab",
+                  href: _ctx.availableQuotaLink
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(_ctx.$t("biz.components.Gpu.viewNamespaceAvailableQuota")), 1)
+                  ]),
+                  _: 1
+                }, 8, ["href"])
+              ]),
+              _: 1
+            })) : createCommentVNode("", true),
             createVNode(_component_gpu_form_item, mergeProps({
               ref_for: true,
               ref: ($e) => _ctx.rowsRef[index] = $e,
@@ -37,19 +60,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               "exist-types": _ctx.existTypes,
               "used-quota-item": _ctx.getUsedQuotaItem(index),
               "available-quota-item": _ctx.getAvailableQuotaItem(index)
-            }, {
-              targetType: _ctx.targetType,
-              enableRemoteCall: _ctx.enableRemoteCall,
-              enableRangeValidate: _ctx.enableRangeValidate,
-              enableNvidiaVgpuModel: _ctx.enableNvidiaVgpuModel,
-              enableNvidiaVgpuPriority: _ctx.enableNvidiaVgpuPriority,
-              enableNvidiaVgpuSchedulePolicy: _ctx.enableNvidiaVgpuSchedulePolicy,
-              dynamicLimitOne: _ctx.dynamicLimitOne,
-              gpuOptionsMap: _ctx.gpuOptionsMap,
-              getDisplayResource: _ctx.getDisplayResource,
-              nvidiaGpuModels: _ctx.nvidiaGpuModels,
-              gpuSettingsAdaptor: _ctx.gpuSettingsAdaptor
-            }, {
+            }, _ctx.gpuFormItemProps, {
               onChange: ($e) => _ctx.handleRowChange(index, $e),
               onRefreshGpuOptionsMap: _ctx.fetchGpuOptions
             }), createSlots({ _: 2 }, [
@@ -76,17 +87,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               "quota-item": _ctx.sideRows[index],
               "exist-types": _ctx.existTypes,
               "is-side": ""
-            }, {
-              targetType: _ctx.targetType,
-              enableRemoteCall: _ctx.enableRemoteCall,
-              enableRangeValidate: _ctx.enableRangeValidate,
-              enableNvidiaVgpuModel: _ctx.enableNvidiaVgpuModel,
-              enableNvidiaVgpuPriority: _ctx.enableNvidiaVgpuPriority,
-              gpuOptionsMap: _ctx.gpuOptionsMap,
-              getDisplayResource: _ctx.getDisplayResource,
-              nvidiaGpuModels: _ctx.nvidiaGpuModels,
-              gpuSettingsAdaptor: _ctx.gpuSettingsAdaptor
-            }), createSlots({ _: 2 }, [
+            }, _ctx.sideGpuFormItemProps), createSlots({ _: 2 }, [
               renderList(_ctx.$slots, (slotValue, slotName) => {
                 return {
                   name: slotName,

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

@@ -1,18 +1,20 @@
 "use strict";
 const vue = require("vue");
 const lodashEs = require("lodash-es");
+const extend = require("@dao-style/extend");
 const props = require("../props.js");
-const types = require("../types.js");
-const GpuFormItem = require("./GpuFormItem.vue.js");
+const GpuFormItem = require("./components/GpuFormItem.vue.js");
 const useGPUOptions = require("./useGPUOptions.js");
-const utils = require("../utils.js");
+const gpuForm_mapper = require("./gpuForm.mapper.js");
+const useGpuFormState = require("./useGpuFormState.js");
+const useGpuFormSideState = require("./useGpuFormSideState.js");
+require("../style/assign-gpu-devices-list.scss.js");
 require("../style/gpu-form-item.scss.js");
 require("../style/gpu-form.scss.js");
-const randomStr = require("../../../utils/randomStr.js");
-const formatNumUnit = require("../../../utils/formatNumUnit.js");
 const _sfc_main = vue.defineComponent({
   name: "DaoGpuForm",
   components: {
+    DaoHistoryLink: extend.DaoHistoryLink,
     GpuFormItem
   },
   props: props.gpuFormProps,
@@ -21,11 +23,11 @@ const _sfc_main = vue.defineComponent({
     "update:nvidiaVgpuModel",
     "update:nvidiaVgpuPriority",
     "update:nvidiaVgpuGpuSchedule",
-    "update:nvidiaVgpuNodeSchedule"
+    "update:nvidiaVgpuNodeSchedule",
+    "update:nvidiaVgpuDevices"
   ],
   setup(props$1, { emit }) {
     const isLimitOne = vue.computed(() => props$1.limit === 1);
-    const showSide = vue.computed(() => !!props$1.usedQuota || !!props$1.availableQuota);
     const {
       gpuOptionsMap,
       getDisplayResource,
@@ -45,114 +47,66 @@ const _sfc_main = vue.defineComponent({
       }, []);
       nvidiaGpuModels.value = Array.from(new Set(modelsArray));
     };
-    const rows = vue.ref([]);
-    const sideRows = vue.ref([]);
-    const rowsRef = vue.ref([]);
-    const existTypes = vue.computed(() => rows.value.reduce((pre, row) => {
-      if (row.type) {
-        pre.push(row.type);
-      }
-      return pre;
-    }, []));
+    const {
+      rows,
+      rowsRef,
+      existTypes,
+      updateRow,
+      addRow,
+      removeRow,
+      filterRows,
+      validate
+    } = useGpuFormState.useGpuFormState();
+    const {
+      sideRows,
+      showSide,
+      sideQuota,
+      syncSideRowChange,
+      syncSideRowAdd,
+      syncSideRowDelete,
+      syncFilter,
+      initSideRows,
+      getUsedQuotaItem,
+      getAvailableQuotaItem
+    } = useGpuFormSideState.useGpuFormSideState({
+      usedQuota: vue.computed(() => props$1.usedQuota),
+      availableQuota: vue.computed(() => props$1.availableQuota),
+      gpuOptionsMap,
+      withPrefixRequest: vue.computed(() => props$1.withPrefixRequest)
+    });
     const formatToUpdate = () => {
-      let currentNvidiaVgpuModel = "";
-      let currentNvidiaVgpuPriority = "";
-      let currentNvidiaVgpuGpuSchedule;
-      let currentNvidiaVgpuNodeSchedule;
-      const resources = rows.value.reduce((pre, row) => {
-        const {
-          type,
-          resources: rest,
-          [types.nvidiaVgpuModelKey]: nvidiaVgpuModel,
-          [types.nvidiaVgpuPriorityKey]: nvidiaVgpuPriority,
-          [types.nvidiaVgpuGpuScheduleKey]: nvidiaVgpuGpuSchedule,
-          [types.nvidiaVgpuNodeScheduleKey]: nvidiaVgpuNodeSchedule
-        } = row;
-        const vgpuResource = Object.entries(rest ?? {}).reduce((preRes, [key, val]) => {
-          const finalResourceKey = utils.deSanitizeGPUKey(key) ?? "";
-          Object.assign(preRes, {
-            [props$1.withPrefixRequest ? `requests.${finalResourceKey}` : finalResourceKey]: val
-          });
-          return preRes;
-        }, {});
-        Object.assign(pre, vgpuResource);
-        if (type === props.nvidiaVgpuKey) {
-          currentNvidiaVgpuModel = nvidiaVgpuModel;
-          currentNvidiaVgpuPriority = nvidiaVgpuPriority;
-          currentNvidiaVgpuGpuSchedule = nvidiaVgpuGpuSchedule;
-          currentNvidiaVgpuNodeSchedule = nvidiaVgpuNodeSchedule;
-        } else {
-          currentNvidiaVgpuModel = void 0;
-          currentNvidiaVgpuPriority = void 0;
-          currentNvidiaVgpuGpuSchedule = void 0;
-          currentNvidiaVgpuNodeSchedule = void 0;
-        }
-        return pre;
-      }, {});
-      const res = {
-        types: existTypes.value,
-        resources
-      };
-      emit("change", res);
+      const formattedUpdate = gpuForm_mapper.buildGpuFormFormattedUpdate(
+        rows.value,
+        existTypes.value,
+        props$1.withPrefixRequest
+      );
+      emit("change", formattedUpdate.change);
       const vgpuExist = existTypes.value.includes(props.nvidiaVgpuKey);
-      if (props$1.enableNvidiaVgpuModel && vgpuExist) {
-        emit("update:nvidiaVgpuModel", currentNvidiaVgpuModel);
-      } else if (props$1.nvidiaVgpuModel) {
-        emit("update:nvidiaVgpuModel", void 0);
-      }
-      if (props$1.enableNvidiaVgpuPriority && vgpuExist) {
-        emit("update:nvidiaVgpuPriority", currentNvidiaVgpuPriority);
-      } else if (props$1.nvidiaVgpuPriority) {
-        emit("update:nvidiaVgpuPriority", void 0);
-      }
-      if (props$1.enableNvidiaVgpuSchedulePolicy && vgpuExist) {
-        emit("update:nvidiaVgpuGpuSchedule", currentNvidiaVgpuGpuSchedule);
-        emit("update:nvidiaVgpuNodeSchedule", currentNvidiaVgpuNodeSchedule);
-      } else if (props$1.nvidiaVgpuGpuSchedule || props$1.nvidiaVgpuNodeSchedule) {
-        emit("update:nvidiaVgpuGpuSchedule", void 0);
-        emit("update:nvidiaVgpuNodeSchedule", void 0);
-      }
+      gpuForm_mapper.buildGpuFormVgpuUpdateEmits(
+        formattedUpdate.vgpu,
+        props$1,
+        vgpuExist
+      ).forEach(([event, value]) => {
+        if (event === "update:nvidiaVgpuDevices") {
+          emit(event, value);
+          return;
+        }
+        emit(event, value);
+      });
     };
-    const sideQuota = vue.computed(() => props$1.usedQuota ?? props$1.availableQuota);
     const handleRowChange = (idx, newRow) => {
-      var _a, _b;
-      rows.value[idx] = newRow;
-      if (showSide.value) {
-        const sideNewRow = lodashEs.cloneDeep(newRow);
-        sideRows.value[idx] = sideNewRow;
-        const sideRow = sideRows.value[idx];
-        sideRow.type = (_a = sideNewRow.type) == null ? void 0 : _a.toString();
-        const currentGpuSettings = gpuOptionsMap.value.get(sideRow.type ?? "");
-        sideRow.resources = {};
-        (_b = currentGpuSettings == null ? void 0 : currentGpuSettings.resource) == null ? void 0 : _b.forEach(({ key }) => {
-          var _a2;
-          const actualKey = props$1.withPrefixRequest ? `requests.${key}` : key;
-          const val = (_a2 = sideQuota.value) == null ? void 0 : _a2.resources[actualKey ?? ""];
-          if (val !== void 0) {
-            lodashEs.set(sideRow, ["resources", utils.sanitizeGPUKey(key) ?? ""], formatNumUnit.formatNumUnit(val));
-          }
-        });
-      }
+      updateRow(idx, newRow);
+      syncSideRowChange(idx, newRow);
       formatToUpdate();
     };
     const handleAdd = () => {
-      rows.value.push({
-        id: randomStr.randomStr(3),
-        type: ""
-      });
-      if (showSide.value) {
-        sideRows.value.push({
-          id: randomStr.randomStr(3),
-          type: ""
-        });
-      }
+      addRow();
+      syncSideRowAdd();
       formatToUpdate();
     };
     const handleDeleteRow = (idx) => {
-      rows.value.splice(idx, 1);
-      if (sideRows.value.length) {
-        sideRows.value.splice(idx, 1);
-      }
+      removeRow(idx);
+      syncSideRowDelete(idx);
       formatToUpdate();
     };
     const enableGpu = vue.computed({
@@ -167,101 +121,32 @@ const _sfc_main = vue.defineComponent({
         }
       }
     });
-    const getUpdateRows = (items) => {
-      const diffRows = [];
-      items.forEach((v) => {
-        if (v.type && gpuOptionsMap.value.has(v.type)) {
-          diffRows.push(v);
-        }
-      });
-      if (!diffRows.length) {
-        return [{
-          id: randomStr.randomStr(3),
-          type: ""
-        }];
-      }
-      return diffRows;
-    };
     const initValues = () => {
       if (rows.value.length || sideRows.value.length) {
-        rows.value = getUpdateRows(rows.value);
-        sideRows.value = getUpdateRows(sideRows.value);
+        filterRows(gpuOptionsMap.value);
+        syncFilter();
         formatToUpdate();
         return;
       }
-      const { types: types$1, resources } = lodashEs.cloneDeep(props$1.quota);
-      const {
-        types: availableTypes
-      } = props$1.availableQuota ?? {};
-      const newTypes = [.../* @__PURE__ */ new Set([...availableTypes ?? [], ...types$1])];
-      const tempRows = [];
-      const tempSideRows = [];
-      newTypes.forEach((type) => {
-        if (!gpuOptionsMap.value.has(type)) {
-          return;
-        }
-        const row = {
-          id: randomStr.randomStr(3),
-          removable: !(availableTypes == null ? void 0 : availableTypes.includes(type)),
-          type
-        };
-        const tempSideRow = {
-          type,
-          id: randomStr.randomStr(3),
-          resources: {}
-        };
-        const displayResource = getDisplayResource(type);
-        if (displayResource.length) {
-          displayResource.forEach((rs) => {
-            var _a;
-            const key = props$1.withPrefixRequest ? `requests.${rs.key}` : rs.key;
-            const val = resources[key];
-            if (val !== void 0) {
-              lodashEs.set(row, ["resources", utils.sanitizeGPUKey(rs.key) ?? ""], formatNumUnit.formatNumUnit(val));
-            }
-            if (showSide.value) {
-              const sideVal = (_a = sideQuota.value) == null ? void 0 : _a.resources[key];
-              if (sideVal !== void 0) {
-                lodashEs.set(tempSideRow, ["resources", utils.sanitizeGPUKey(rs.key) ?? ""], formatNumUnit.formatNumUnit(sideVal));
-              }
-            }
-          });
-          if (type === props.nvidiaVgpuKey && isLimitOne.value) {
-            const vgpuModel = props$1.nvidiaVgpuModel;
-            if (vgpuModel) {
-              Object.assign(row, {
-                [types.nvidiaVgpuModelKey]: vgpuModel
-              });
-            }
-            const priority = props$1.nvidiaVgpuPriority;
-            if (priority) {
-              Object.assign(row, {
-                [types.nvidiaVgpuPriorityKey]: priority
-              });
-            }
-            const gpuSchedule = props$1.nvidiaVgpuGpuSchedule;
-            const nodeSchedule = props$1.nvidiaVgpuNodeSchedule;
-            if (gpuSchedule) {
-              Object.assign(row, {
-                [types.nvidiaVgpuGpuScheduleKey]: gpuSchedule
-              });
-            }
-            if (nodeSchedule) {
-              Object.assign(row, {
-                [types.nvidiaVgpuNodeScheduleKey]: nodeSchedule
-              });
-            }
-          }
-        }
-        if (showSide.value && !tempSideRows.includes(tempSideRow)) {
-          tempSideRows.push(tempSideRow);
-        }
-        if (!tempRows.includes(row)) {
-          tempRows.push(row);
+      const initialRows = gpuForm_mapper.buildGpuFormInitialRows({
+        quota: lodashEs.cloneDeep(props$1.quota),
+        availableQuota: props$1.availableQuota,
+        sideQuota: sideQuota.value,
+        gpuOptionsMap: gpuOptionsMap.value,
+        getDisplayResource,
+        withPrefixRequest: props$1.withPrefixRequest,
+        showSide: showSide.value,
+        isLimitOne: isLimitOne.value,
+        vgpu: {
+          nvidiaVgpuModel: props$1.nvidiaVgpuModel,
+          nvidiaVgpuDevices: props$1.nvidiaVgpuDevices,
+          nvidiaVgpuPriority: props$1.nvidiaVgpuPriority,
+          nvidiaVgpuGpuSchedule: props$1.nvidiaVgpuGpuSchedule,
+          nvidiaVgpuNodeSchedule: props$1.nvidiaVgpuNodeSchedule
         }
       });
-      sideRows.value = tempSideRows;
-      rows.value = tempRows;
+      initSideRows(initialRows.sideRows);
+      rows.value = initialRows.rows;
       formatToUpdate();
     };
     vue.watch([
@@ -273,35 +158,45 @@ const _sfc_main = vue.defineComponent({
       if (!fetchingGpuOptions.value) {
         initValues();
       }
-      if (props$1.enableNvidiaVgpuModel && gpuOptionsMap.value.has(props.nvidiaVgpuKey) && !nvidiaGpuModels.value.length) {
-        fetchNvidiaVgpuModels();
+      const selectedModelMissing = Boolean(props$1.nvidiaVgpuModel) && !nvidiaGpuModels.value.includes(props$1.nvidiaVgpuModel);
+      const shouldFetchNvidiaVgpuModels = props$1.enableNvidiaVgpuModel && gpuOptionsMap.value.has(props.nvidiaVgpuKey) && (!nvidiaGpuModels.value.length || props$1.assignGpuDisabled && selectedModelMissing);
+      if (shouldFetchNvidiaVgpuModels) {
+        await fetchNvidiaVgpuModels();
       }
     }, {
       immediate: true
     });
-    const validate = async () => {
-      const validsRes = await Promise.all(
-        rowsRef.value.map((row) => {
-          var _a;
-          return ((_a = row == null ? void 0 : row.validate) == null ? void 0 : _a.call(row)) ?? { valid: true };
-        })
-      );
-      return validsRes.every((v) => v.valid);
-    };
-    const getUsedQuotaItem = (index) => {
-      var _a;
-      if (props$1.usedQuota) {
-        return (_a = sideRows.value) == null ? void 0 : _a[index];
-      }
-      return void 0;
-    };
-    const getAvailableQuotaItem = (index) => {
-      var _a;
-      if (props$1.availableQuota) {
-        return (_a = sideRows.value) == null ? void 0 : _a[index];
-      }
-      return void 0;
-    };
+    const gpuFormItemBaseProps = vue.computed(() => ({
+      targetType: props$1.targetType,
+      enableRangeValidate: props$1.enableRangeValidate,
+      gpuOptionsMap: gpuOptionsMap.value,
+      getDisplayResource,
+      gpuUsage: props$1.gpuUsage,
+      gpuSettingsAdaptor: props$1.gpuSettingsAdaptor
+    }));
+    const sharedGpuFormItemAdvancedProps = vue.computed(() => ({
+      enableRemoteCall: props$1.enableRemoteCall,
+      enableNvidiaVgpuModel: props$1.enableNvidiaVgpuModel,
+      enableNvidiaVgpuDevices: props$1.enableNvidiaVgpuDevices,
+      assignGpuDisabled: props$1.assignGpuDisabled,
+      enableNvidiaVgpuPriority: props$1.enableNvidiaVgpuPriority,
+      nvidiaGpuModels: nvidiaGpuModels.value,
+      nvidiaVgpuModelsAdaptor: props$1.nvidiaVgpuModelsAdaptor,
+      nvidiaVgpuDevicesAdaptor: props$1.nvidiaVgpuDevicesAdaptor
+    }));
+    const gpuFormItemAdvancedProps = vue.computed(() => ({
+      ...sharedGpuFormItemAdvancedProps.value,
+      enableNvidiaVgpuSchedulePolicy: props$1.enableNvidiaVgpuSchedulePolicy
+    }));
+    const gpuFormItemProps = vue.computed(() => ({
+      ...gpuFormItemBaseProps.value,
+      ...gpuFormItemAdvancedProps.value,
+      dynamicLimitOne: props$1.dynamicLimitOne
+    }));
+    const sideGpuFormItemProps = vue.computed(() => ({
+      ...gpuFormItemBaseProps.value,
+      ...sharedGpuFormItemAdvancedProps.value
+    }));
     return {
       isLimitOne,
       rows,
@@ -315,6 +210,8 @@ const _sfc_main = vue.defineComponent({
       fetchGpuOptions,
       getDisplayResource,
       nvidiaGpuModels,
+      gpuFormItemProps,
+      sideGpuFormItemProps,
       showSide,
       sideRows,
       validate,