@dao-style/biz 0.6.0 → 0.7.0

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

@@ -1,17 +1,19 @@
 import { defineComponent, computed, ref, watch } from "vue";
-import { cloneDeep, set } from "lodash-es";
+import { cloneDeep } from "lodash-es";
+import { DaoHistoryLink } from "@dao-style/extend";
 import { gpuFormProps, nvidiaVgpuKey } from "../props.mjs";
-import { nvidiaVgpuModelKey, nvidiaVgpuPriorityKey, nvidiaVgpuGpuScheduleKey, nvidiaVgpuNodeScheduleKey } from "../types.mjs";
-import GpuFormItem from "./GpuFormItem.vue.mjs";
+import GpuFormItem from "./components/GpuFormItem.vue.mjs";
 import { useGPUOptions } from "./useGPUOptions.mjs";
-import { sanitizeGPUKey, deSanitizeGPUKey } from "../utils.mjs";
+import { buildGpuFormInitialRows, buildGpuFormFormattedUpdate, buildGpuFormVgpuUpdateEmits } from "./gpuForm.mapper.mjs";
+import { useGpuFormState } from "./useGpuFormState.mjs";
+import { useGpuFormSideState } from "./useGpuFormSideState.mjs";
+import "../style/assign-gpu-devices-list.scss.mjs";
 import "../style/gpu-form-item.scss.mjs";
 import "../style/gpu-form.scss.mjs";
-import { randomStr } from "../../../utils/randomStr.mjs";
-import { formatNumUnit } from "../../../utils/formatNumUnit.mjs";
 const _sfc_main = defineComponent({
   name: "DaoGpuForm",
   components: {
+    DaoHistoryLink,
     GpuFormItem
   },
   props: gpuFormProps,
@@ -20,11 +22,11 @@ const _sfc_main = defineComponent({
     "update:nvidiaVgpuModel",
     "update:nvidiaVgpuPriority",
     "update:nvidiaVgpuGpuSchedule",
-    "update:nvidiaVgpuNodeSchedule"
+    "update:nvidiaVgpuNodeSchedule",
+    "update:nvidiaVgpuDevices"
   ],
   setup(props, { emit }) {
     const isLimitOne = computed(() => props.limit === 1);
-    const showSide = computed(() => !!props.usedQuota || !!props.availableQuota);
     const {
       gpuOptionsMap,
       getDisplayResource,
@@ -44,114 +46,66 @@ const _sfc_main = defineComponent({
       }, []);
       nvidiaGpuModels.value = Array.from(new Set(modelsArray));
     };
-    const rows = ref([]);
-    const sideRows = ref([]);
-    const rowsRef = ref([]);
-    const existTypes = 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();
+    const {
+      sideRows,
+      showSide,
+      sideQuota,
+      syncSideRowChange,
+      syncSideRowAdd,
+      syncSideRowDelete,
+      syncFilter,
+      initSideRows,
+      getUsedQuotaItem,
+      getAvailableQuotaItem
+    } = useGpuFormSideState({
+      usedQuota: computed(() => props.usedQuota),
+      availableQuota: computed(() => props.availableQuota),
+      gpuOptionsMap,
+      withPrefixRequest: computed(() => props.withPrefixRequest)
+    });
     const formatToUpdate = () => {
-      let currentNvidiaVgpuModel = "";
-      let currentNvidiaVgpuPriority = "";
-      let currentNvidiaVgpuGpuSchedule;
-      let currentNvidiaVgpuNodeSchedule;
-      const resources = rows.value.reduce((pre, row) => {
-        const {
-          type,
-          resources: rest,
-          [nvidiaVgpuModelKey]: nvidiaVgpuModel,
-          [nvidiaVgpuPriorityKey]: nvidiaVgpuPriority,
-          [nvidiaVgpuGpuScheduleKey]: nvidiaVgpuGpuSchedule,
-          [nvidiaVgpuNodeScheduleKey]: nvidiaVgpuNodeSchedule
-        } = row;
-        const vgpuResource = Object.entries(rest ?? {}).reduce((preRes, [key, val]) => {
-          const finalResourceKey = deSanitizeGPUKey(key) ?? "";
-          Object.assign(preRes, {
-            [props.withPrefixRequest ? `requests.${finalResourceKey}` : finalResourceKey]: val
-          });
-          return preRes;
-        }, {});
-        Object.assign(pre, vgpuResource);
-        if (type === 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 = buildGpuFormFormattedUpdate(
+        rows.value,
+        existTypes.value,
+        props.withPrefixRequest
+      );
+      emit("change", formattedUpdate.change);
       const vgpuExist = existTypes.value.includes(nvidiaVgpuKey);
-      if (props.enableNvidiaVgpuModel && vgpuExist) {
-        emit("update:nvidiaVgpuModel", currentNvidiaVgpuModel);
-      } else if (props.nvidiaVgpuModel) {
-        emit("update:nvidiaVgpuModel", void 0);
-      }
-      if (props.enableNvidiaVgpuPriority && vgpuExist) {
-        emit("update:nvidiaVgpuPriority", currentNvidiaVgpuPriority);
-      } else if (props.nvidiaVgpuPriority) {
-        emit("update:nvidiaVgpuPriority", void 0);
-      }
-      if (props.enableNvidiaVgpuSchedulePolicy && vgpuExist) {
-        emit("update:nvidiaVgpuGpuSchedule", currentNvidiaVgpuGpuSchedule);
-        emit("update:nvidiaVgpuNodeSchedule", currentNvidiaVgpuNodeSchedule);
-      } else if (props.nvidiaVgpuGpuSchedule || props.nvidiaVgpuNodeSchedule) {
-        emit("update:nvidiaVgpuGpuSchedule", void 0);
-        emit("update:nvidiaVgpuNodeSchedule", void 0);
-      }
+      buildGpuFormVgpuUpdateEmits(
+        formattedUpdate.vgpu,
+        props,
+        vgpuExist
+      ).forEach(([event, value]) => {
+        if (event === "update:nvidiaVgpuDevices") {
+          emit(event, value);
+          return;
+        }
+        emit(event, value);
+      });
     };
-    const sideQuota = computed(() => props.usedQuota ?? props.availableQuota);
     const handleRowChange = (idx, newRow) => {
-      var _a, _b;
-      rows.value[idx] = newRow;
-      if (showSide.value) {
-        const sideNewRow = 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.withPrefixRequest ? `requests.${key}` : key;
-          const val = (_a2 = sideQuota.value) == null ? void 0 : _a2.resources[actualKey ?? ""];
-          if (val !== void 0) {
-            set(sideRow, ["resources", sanitizeGPUKey(key) ?? ""], formatNumUnit(val));
-          }
-        });
-      }
+      updateRow(idx, newRow);
+      syncSideRowChange(idx, newRow);
       formatToUpdate();
     };
     const handleAdd = () => {
-      rows.value.push({
-        id: randomStr(3),
-        type: ""
-      });
-      if (showSide.value) {
-        sideRows.value.push({
-          id: 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 = computed({
@@ -166,101 +120,32 @@ const _sfc_main = 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(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, resources } = cloneDeep(props.quota);
-      const {
-        types: availableTypes
-      } = props.availableQuota ?? {};
-      const newTypes = [.../* @__PURE__ */ new Set([...availableTypes ?? [], ...types])];
-      const tempRows = [];
-      const tempSideRows = [];
-      newTypes.forEach((type) => {
-        if (!gpuOptionsMap.value.has(type)) {
-          return;
-        }
-        const row = {
-          id: randomStr(3),
-          removable: !(availableTypes == null ? void 0 : availableTypes.includes(type)),
-          type
-        };
-        const tempSideRow = {
-          type,
-          id: randomStr(3),
-          resources: {}
-        };
-        const displayResource = getDisplayResource(type);
-        if (displayResource.length) {
-          displayResource.forEach((rs) => {
-            var _a;
-            const key = props.withPrefixRequest ? `requests.${rs.key}` : rs.key;
-            const val = resources[key];
-            if (val !== void 0) {
-              set(row, ["resources", sanitizeGPUKey(rs.key) ?? ""], formatNumUnit(val));
-            }
-            if (showSide.value) {
-              const sideVal = (_a = sideQuota.value) == null ? void 0 : _a.resources[key];
-              if (sideVal !== void 0) {
-                set(tempSideRow, ["resources", sanitizeGPUKey(rs.key) ?? ""], formatNumUnit(sideVal));
-              }
-            }
-          });
-          if (type === nvidiaVgpuKey && isLimitOne.value) {
-            const vgpuModel = props.nvidiaVgpuModel;
-            if (vgpuModel) {
-              Object.assign(row, {
-                [nvidiaVgpuModelKey]: vgpuModel
-              });
-            }
-            const priority = props.nvidiaVgpuPriority;
-            if (priority) {
-              Object.assign(row, {
-                [nvidiaVgpuPriorityKey]: priority
-              });
-            }
-            const gpuSchedule = props.nvidiaVgpuGpuSchedule;
-            const nodeSchedule = props.nvidiaVgpuNodeSchedule;
-            if (gpuSchedule) {
-              Object.assign(row, {
-                [nvidiaVgpuGpuScheduleKey]: gpuSchedule
-              });
-            }
-            if (nodeSchedule) {
-              Object.assign(row, {
-                [nvidiaVgpuNodeScheduleKey]: nodeSchedule
-              });
-            }
-          }
-        }
-        if (showSide.value && !tempSideRows.includes(tempSideRow)) {
-          tempSideRows.push(tempSideRow);
-        }
-        if (!tempRows.includes(row)) {
-          tempRows.push(row);
+      const initialRows = buildGpuFormInitialRows({
+        quota: cloneDeep(props.quota),
+        availableQuota: props.availableQuota,
+        sideQuota: sideQuota.value,
+        gpuOptionsMap: gpuOptionsMap.value,
+        getDisplayResource,
+        withPrefixRequest: props.withPrefixRequest,
+        showSide: showSide.value,
+        isLimitOne: isLimitOne.value,
+        vgpu: {
+          nvidiaVgpuModel: props.nvidiaVgpuModel,
+          nvidiaVgpuDevices: props.nvidiaVgpuDevices,
+          nvidiaVgpuPriority: props.nvidiaVgpuPriority,
+          nvidiaVgpuGpuSchedule: props.nvidiaVgpuGpuSchedule,
+          nvidiaVgpuNodeSchedule: props.nvidiaVgpuNodeSchedule
         }
       });
-      sideRows.value = tempSideRows;
-      rows.value = tempRows;
+      initSideRows(initialRows.sideRows);
+      rows.value = initialRows.rows;
       formatToUpdate();
     };
     watch([
@@ -272,35 +157,45 @@ const _sfc_main = defineComponent({
       if (!fetchingGpuOptions.value) {
         initValues();
       }
-      if (props.enableNvidiaVgpuModel && gpuOptionsMap.value.has(nvidiaVgpuKey) && !nvidiaGpuModels.value.length) {
-        fetchNvidiaVgpuModels();
+      const selectedModelMissing = Boolean(props.nvidiaVgpuModel) && !nvidiaGpuModels.value.includes(props.nvidiaVgpuModel);
+      const shouldFetchNvidiaVgpuModels = props.enableNvidiaVgpuModel && gpuOptionsMap.value.has(nvidiaVgpuKey) && (!nvidiaGpuModels.value.length || props.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.usedQuota) {
-        return (_a = sideRows.value) == null ? void 0 : _a[index];
-      }
-      return void 0;
-    };
-    const getAvailableQuotaItem = (index) => {
-      var _a;
-      if (props.availableQuota) {
-        return (_a = sideRows.value) == null ? void 0 : _a[index];
-      }
-      return void 0;
-    };
+    const gpuFormItemBaseProps = computed(() => ({
+      targetType: props.targetType,
+      enableRangeValidate: props.enableRangeValidate,
+      gpuOptionsMap: gpuOptionsMap.value,
+      getDisplayResource,
+      gpuUsage: props.gpuUsage,
+      gpuSettingsAdaptor: props.gpuSettingsAdaptor
+    }));
+    const sharedGpuFormItemAdvancedProps = computed(() => ({
+      enableRemoteCall: props.enableRemoteCall,
+      enableNvidiaVgpuModel: props.enableNvidiaVgpuModel,
+      enableNvidiaVgpuDevices: props.enableNvidiaVgpuDevices,
+      assignGpuDisabled: props.assignGpuDisabled,
+      enableNvidiaVgpuPriority: props.enableNvidiaVgpuPriority,
+      nvidiaGpuModels: nvidiaGpuModels.value,
+      nvidiaVgpuModelsAdaptor: props.nvidiaVgpuModelsAdaptor,
+      nvidiaVgpuDevicesAdaptor: props.nvidiaVgpuDevicesAdaptor
+    }));
+    const gpuFormItemAdvancedProps = computed(() => ({
+      ...sharedGpuFormItemAdvancedProps.value,
+      enableNvidiaVgpuSchedulePolicy: props.enableNvidiaVgpuSchedulePolicy
+    }));
+    const gpuFormItemProps = computed(() => ({
+      ...gpuFormItemBaseProps.value,
+      ...gpuFormItemAdvancedProps.value,
+      dynamicLimitOne: props.dynamicLimitOne
+    }));
+    const sideGpuFormItemProps = computed(() => ({
+      ...gpuFormItemBaseProps.value,
+      ...sharedGpuFormItemAdvancedProps.value
+    }));
     return {
       isLimitOne,
       rows,
@@ -314,6 +209,8 @@ const _sfc_main = defineComponent({
       fetchGpuOptions,
       getDisplayResource,
       nvidiaGpuModels,
+      gpuFormItemProps,
+      sideGpuFormItemProps,
       showSide,
       sideRows,
       validate,

package/dist/components/gpu/src/components/AssignGpuDevicesList.vue.d.ts

@@ -0,0 +1,77 @@
+import '../../style/assign-gpu-devices-list';
+import { GpuDevice } from '../../props';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    nvidiaVgpuDevicesAdaptor: {
+        type: import("vue").PropType<import("../../props").GpuDevicesAdaptor>;
+        default: undefined;
+    };
+}, {
+    columns: import("vue").ComputedRef<({
+        header: string;
+        id: string;
+        defaultWidth?: undefined;
+    } | {
+        header: string;
+        id: string;
+        defaultWidth: string;
+    })[]>;
+    selectedDevices: import("vue").ComputedRef<GpuDevice[]>;
+    displayDevices: import("vue").ComputedRef<GpuDevice[]>;
+    onSelect: (selected: GpuDevice[]) => void;
+    getRowCheckable: (row: GpuDevice) => boolean;
+    displayComputePower: (row: GpuDevice) => string;
+    displayMemory: (row: GpuDevice) => string;
+    searchOptions: import("vue").ComputedRef<{
+        key: string;
+        label: string;
+        single: boolean;
+    }[]>;
+    fuzzySearch: {
+        key: string;
+        single: boolean;
+    };
+    filterData: import("vue").Ref<{
+        searchDeviceUUID?: string[] | undefined;
+        searchNodeName?: string[] | undefined;
+        searchGPUModel?: string[] | undefined;
+    }>;
+    handleSearch: () => void;
+    handleRefresh: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    nvidiaVgpuDevicesAdaptor: {
+        type: import("vue").PropType<import("../../props").GpuDevicesAdaptor>;
+        default: undefined;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: string[];
+    id: string;
+    disabled: boolean;
+    nvidiaVgpuDevicesAdaptor: import("../../props").GpuDevicesAdaptor;
+}>;
+export default _default;

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

@@ -0,0 +1,40 @@
+"use strict";
+const AssignGpuDevicesList_vue_vue_type_script_lang = require("./AssignGpuDevicesList.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) {
+  var _a, _b;
+  const _component_dao_table = vue.resolveComponent("dao-table");
+  return vue.openBlock(), vue.createBlock(_component_dao_table, {
+    id: _ctx.id,
+    search: _ctx.filterData,
+    "onUpdate:search": _cache[0] || (_cache[0] = ($event) => _ctx.filterData = $event),
+    class: "dao-assign-gpu-devices-list",
+    "selected-rows": _ctx.selectedDevices,
+    loading: (_a = _ctx.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.loading,
+    columns: _ctx.columns,
+    data: _ctx.displayDevices,
+    selectable: _ctx.getRowCheckable,
+    "page-layout": [],
+    compact: "",
+    "hide-batch-bar": "",
+    multiple: "",
+    "no-shadow": "",
+    "hide-search": _ctx.disabled || !((_b = _ctx.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _b.search),
+    "search-options": _ctx.searchOptions,
+    fuzzy: _ctx.fuzzySearch,
+    onSelect: _ctx.onSelect,
+    onRefresh: _ctx.handleRefresh,
+    onSearch: _ctx.handleSearch
+  }, {
+    "td-memory": vue.withCtx(({ row }) => [
+      vue.createTextVNode(vue.toDisplayString(_ctx.displayMemory(row)), 1)
+    ]),
+    "td-computePower": vue.withCtx(({ row }) => [
+      vue.createTextVNode(vue.toDisplayString(_ctx.displayComputePower(row)), 1)
+    ]),
+    _: 1
+  }, 8, ["id", "search", "selected-rows", "loading", "columns", "data", "selectable", "hide-search", "search-options", "fuzzy", "onSelect", "onRefresh", "onSearch"]);
+}
+const DaoAssignGpuDevicesList = /* @__PURE__ */ _pluginVue_exportHelper(AssignGpuDevicesList_vue_vue_type_script_lang, [["render", _sfc_render]]);
+module.exports = DaoAssignGpuDevicesList;

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

@@ -0,0 +1,41 @@
+import _sfc_main from "./AssignGpuDevicesList.vue2.mjs";
+import { resolveComponent, openBlock, createBlock, withCtx, createTextVNode, toDisplayString } from "vue";
+import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.mjs";
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  var _a, _b;
+  const _component_dao_table = resolveComponent("dao-table");
+  return openBlock(), createBlock(_component_dao_table, {
+    id: _ctx.id,
+    search: _ctx.filterData,
+    "onUpdate:search": _cache[0] || (_cache[0] = ($event) => _ctx.filterData = $event),
+    class: "dao-assign-gpu-devices-list",
+    "selected-rows": _ctx.selectedDevices,
+    loading: (_a = _ctx.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _a.loading,
+    columns: _ctx.columns,
+    data: _ctx.displayDevices,
+    selectable: _ctx.getRowCheckable,
+    "page-layout": [],
+    compact: "",
+    "hide-batch-bar": "",
+    multiple: "",
+    "no-shadow": "",
+    "hide-search": _ctx.disabled || !((_b = _ctx.nvidiaVgpuDevicesAdaptor) == null ? void 0 : _b.search),
+    "search-options": _ctx.searchOptions,
+    fuzzy: _ctx.fuzzySearch,
+    onSelect: _ctx.onSelect,
+    onRefresh: _ctx.handleRefresh,
+    onSearch: _ctx.handleSearch
+  }, {
+    "td-memory": withCtx(({ row }) => [
+      createTextVNode(toDisplayString(_ctx.displayMemory(row)), 1)
+    ]),
+    "td-computePower": withCtx(({ row }) => [
+      createTextVNode(toDisplayString(_ctx.displayComputePower(row)), 1)
+    ]),
+    _: 1
+  }, 8, ["id", "search", "selected-rows", "loading", "columns", "data", "selectable", "hide-search", "search-options", "fuzzy", "onSelect", "onRefresh", "onSearch"]);
+}
+const DaoAssignGpuDevicesList = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  DaoAssignGpuDevicesList as default
+};