@dao-style/biz 0.6.0 → 0.7.0

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

@@ -0,0 +1,153 @@
+import { set } from "lodash-es";
+import { nvidiaVgpuDevicesKey, nvidiaVgpuModelKey, nvidiaVgpuPriorityKey, nvidiaVgpuGpuScheduleKey, nvidiaVgpuNodeScheduleKey } from "../types.mjs";
+import { isValidGPUResourceValue, deSanitizeGPUObjectKey, isNvidiaVgpu, isHamiGpu, sanitizeGPUKey } from "../utils.mjs";
+function buildGpuFormItemDefaultResources(gpuOption, gpuUsage) {
+  var _a;
+  if (gpuUsage !== "workload" || !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 {
+    [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 = deSanitizeGPUObjectKey(resources);
+  } else {
+    Object.entries(resources ?? {}).forEach(([key, val]) => {
+      set(values, ["resources", key], val);
+    });
+  }
+  const isVgpu = isNvidiaVgpu(type ?? "");
+  if (isVgpu && (advanced.enableNvidiaVgpuModel || advanced.enableNvidiaVgpuDevices)) {
+    const devices = quotaItem[nvidiaVgpuDevicesKey];
+    const model = quotaItem[nvidiaVgpuModelKey];
+    const hasDevices = !!(devices == null ? void 0 : devices.length);
+    const hasModel = !!model;
+    openNvidiaAssignGpu = !!(hasDevices || hasModel);
+    if (openNvidiaAssignGpu) {
+      if (hasModel) {
+        values[nvidiaVgpuModelKey] = model;
+      } else if (hasDevices) {
+        values[nvidiaVgpuDevicesKey] = devices;
+      }
+    }
+  }
+  if (isVgpu && advanced.enableNvidiaVgpuSchedulePolicy) {
+    const gpuSchedule = quotaItem[nvidiaVgpuGpuScheduleKey];
+    const nodeSchedule = quotaItem[nvidiaVgpuNodeScheduleKey];
+    openNvidiaVgpuSchedulePolicy = !!gpuSchedule || !!nodeSchedule;
+    if (openNvidiaVgpuSchedulePolicy) {
+      values[nvidiaVgpuGpuScheduleKey] = gpuSchedule;
+      values[nvidiaVgpuNodeScheduleKey] = nodeSchedule;
+    }
+  }
+  if (advanced.enableNvidiaVgpuPriority) {
+    values[nvidiaVgpuPriorityKey] = quotaItem[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]) => isValidGPUResourceValue(value))
+  );
+  const newQuota = {
+    type: quota.type,
+    id: quota.id,
+    resources: deSanitizeGPUObjectKey(validResources),
+    removable: quotaItem.removable
+  };
+  if (isNvidiaVgpu(quota.type)) {
+    if (openNvidiaAssignGpu) {
+      const devices = quota[nvidiaVgpuDevicesKey];
+      const model = quota[nvidiaVgpuModelKey];
+      if (model) {
+        newQuota[nvidiaVgpuModelKey] = model;
+      } else if (devices == null ? void 0 : devices.length) {
+        newQuota[nvidiaVgpuDevicesKey] = devices;
+      }
+    }
+    if (advanced.enableNvidiaVgpuPriority) {
+      newQuota[nvidiaVgpuPriorityKey] = quota[nvidiaVgpuPriorityKey];
+    }
+    if (advanced.enableNvidiaVgpuSchedulePolicy) {
+      if (openNvidiaVgpuSchedulePolicy) {
+        Object.assign(newQuota, {
+          [nvidiaVgpuGpuScheduleKey]: quota[nvidiaVgpuGpuScheduleKey],
+          [nvidiaVgpuNodeScheduleKey]: quota[nvidiaVgpuNodeScheduleKey]
+        });
+      } else {
+        Object.assign(newQuota, {
+          [nvidiaVgpuGpuScheduleKey]: void 0,
+          [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;
+}
+export {
+  buildGpuFormItemChangePayload,
+  buildGpuFormItemDefaultResources,
+  buildGpuFormItemInitialState,
+  filterGpuFormItemOptions
+};

package/dist/components/gpu/src/useGPUOptions.d.ts

@@ -1,6 +1,6 @@
 import { type Ref } from 'vue';
 import { GPUSettings } from '../props';
-import { GPUResourceSetting, GPUSetting } from '../types';
+import { GPUSetting } from '../types';
 export interface UseGPUOptionsParams {
     shouldFetchData?: boolean;
     availableEnable?: boolean;
@@ -14,7 +14,7 @@ export declare const useGPUOptions: (params?: UseGPUOptionsParams) => {
     gpuOptions: GpuOptions;
     gpuOptionsMap: GpuOptionsMap;
     fetchingGpuOptions: FetchingGpuOptions;
-    getDisplayResource: (type: string) => GPUResourceSetting[];
+    getDisplayResource: (type: string) => import("../types").GPUResourceSetting[];
     fetchGpuOptions: () => Promise<GPUSetting[] | undefined>;
     gpuKeyTypeMap: GpuKeyTypeMap;
 };

package/dist/components/gpu/src/useGPUOptions.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("vue");
-const vueI18n = require("vue-i18n");
 const lodashEs = require("lodash-es");
 const props = require("../props.js");
 const gpuFormsMap = /* @__PURE__ */ new Map();
@@ -36,8 +35,6 @@ const useGPUOptions = (params) => {
       gpuFormsMap.delete(id);
     }
   });
-  const i18nInstance = vueI18n.useI18n();
-  const nvidiaVgpuResOrder = props.getNvidiaVgpuResOrder(i18nInstance);
   const fetchGpuOptions = async () => {
     var _a;
     fetchingGpuOptions.value = true;
@@ -82,8 +79,8 @@ const useGPUOptions = (params) => {
     fetchGpuOptions();
   }
   const getDisplayResource = (type) => {
-    var _a;
-    const resource = ((_a = gpuOptionsMap.value.get(type)) == null ? void 0 : _a.resource) ?? [];
+    const gpuSetting = gpuOptionsMap.value.get(type);
+    const resource = (gpuSetting == null ? void 0 : gpuSetting.resource) ?? [];
     const alloResource = resource.filter(
       (rs) => rs.isAllocatable === true || rs.isAllocatable === void 0
     );
@@ -99,23 +96,21 @@ const useGPUOptions = (params) => {
         });
       });
     });
-    if (type === props.nvidiaVgpuKey) {
-      const resourceOrder = [...nvidiaVgpuResOrder.keys()];
-      const preRes = [];
-      const resRes = [];
-      alloResource.forEach((res) => {
-        if (!nvidiaVgpuResOrder.get(res.key ?? "")) {
-          resRes.push(res);
-        } else {
-          const idx = resourceOrder.indexOf(res.key ?? "");
-          if (idx > -1) {
-            preRes[idx] = res;
-          } else {
-            resRes.push(res);
-          }
+    if ((gpuSetting == null ? void 0 : gpuSetting.provider) === "hami") {
+      alloResource.sort((a, b) => {
+        const aIdx = props.hamiResOrder.indexOf(a.type ?? "");
+        const bIdx = props.hamiResOrder.indexOf(b.type ?? "");
+        if (aIdx === -1 && bIdx === -1) {
+          return 0;
+        }
+        if (aIdx === -1) {
+          return 1;
+        }
+        if (bIdx === -1) {
+          return -1;
         }
+        return aIdx - bIdx;
       });
-      return [...preRes, ...resRes];
     }
     return alloResource;
   };

package/dist/components/gpu/src/useGPUOptions.mjs

@@ -1,7 +1,6 @@
 import { ref, onBeforeUnmount } from "vue";
-import { useI18n } from "vue-i18n";
 import { isEqual, merge } from "lodash-es";
-import { getNvidiaVgpuResOrder, nvidiaVgpuKey } from "../props.mjs";
+import { hamiResOrder } from "../props.mjs";
 const gpuFormsMap = /* @__PURE__ */ new Map();
 const useGPUOptions = (params) => {
   const { shouldFetchData = true, gpuSettings } = params ?? {};
@@ -34,8 +33,6 @@ const useGPUOptions = (params) => {
       gpuFormsMap.delete(id);
     }
   });
-  const i18nInstance = useI18n();
-  const nvidiaVgpuResOrder = getNvidiaVgpuResOrder(i18nInstance);
   const fetchGpuOptions = async () => {
     var _a;
     fetchingGpuOptions.value = true;
@@ -80,8 +77,8 @@ const useGPUOptions = (params) => {
     fetchGpuOptions();
   }
   const getDisplayResource = (type) => {
-    var _a;
-    const resource = ((_a = gpuOptionsMap.value.get(type)) == null ? void 0 : _a.resource) ?? [];
+    const gpuSetting = gpuOptionsMap.value.get(type);
+    const resource = (gpuSetting == null ? void 0 : gpuSetting.resource) ?? [];
     const alloResource = resource.filter(
       (rs) => rs.isAllocatable === true || rs.isAllocatable === void 0
     );
@@ -97,23 +94,21 @@ const useGPUOptions = (params) => {
         });
       });
     });
-    if (type === nvidiaVgpuKey) {
-      const resourceOrder = [...nvidiaVgpuResOrder.keys()];
-      const preRes = [];
-      const resRes = [];
-      alloResource.forEach((res) => {
-        if (!nvidiaVgpuResOrder.get(res.key ?? "")) {
-          resRes.push(res);
-        } else {
-          const idx = resourceOrder.indexOf(res.key ?? "");
-          if (idx > -1) {
-            preRes[idx] = res;
-          } else {
-            resRes.push(res);
-          }
+    if ((gpuSetting == null ? void 0 : gpuSetting.provider) === "hami") {
+      alloResource.sort((a, b) => {
+        const aIdx = hamiResOrder.indexOf(a.type ?? "");
+        const bIdx = hamiResOrder.indexOf(b.type ?? "");
+        if (aIdx === -1 && bIdx === -1) {
+          return 0;
+        }
+        if (aIdx === -1) {
+          return 1;
+        }
+        if (bIdx === -1) {
+          return -1;
         }
+        return aIdx - bIdx;
       });
-      return [...preRes, ...resRes];
     }
     return alloResource;
   };

package/dist/components/gpu/src/useGpuFormItemState.d.ts

@@ -0,0 +1,42 @@
+import { type ExtractPropTypes, type Slots } from 'vue';
+import type { VueI18nLike } from '@dao-style/extend';
+import { gpuFormItemProps } from '../props';
+import { type GpuQuotaItem } from '../types';
+type GpuFormItemProps = ExtractPropTypes<typeof gpuFormItemProps>;
+type GpuFormItemEmit = (event: 'change', value: GpuQuotaItem) => void;
+export declare function useGpuFormItemState(props: GpuFormItemProps, emits: GpuFormItemEmit, slots: Slots, i18nInstance: VueI18nLike): {
+    quota: GpuQuotaItem;
+    dynamicQuota: import("vue").Ref<Record<string, string | number | undefined> | undefined>;
+    currentDisplayResource: import("vue").ComputedRef<import("../types").GPUResourceSetting[] | undefined>;
+    currentGpuProvider: import("vue").ComputedRef<string>;
+    isShowHamiGpuHelper: import("vue").ComputedRef<boolean>;
+    filteredGpuOptionsMap: import("vue").ComputedRef<Map<string, import("../types").GPUSetting>>;
+    getGPUTypeInSide: (quotaType?: string) => string;
+    handleTypeChange: (val: unknown) => void;
+    validate: () => Promise<import("vee-validate").FormValidationResult<GpuQuotaItem>> | {
+        valid: boolean;
+    };
+    deSanitizeGPUObjectKey: <T extends Record<string, unknown>>(obj?: T | undefined) => T;
+    gpuResourceHelperSlot: () => string[] | undefined;
+    openNvidiaVgpuModel: import("vue").Ref<boolean>;
+    openNvidiaAssignGpu: import("vue").Ref<boolean>;
+    openNvidiaVgpuSchedulePolicy: import("vue").Ref<boolean>;
+    gpuAdvancedFormProps: import("vue").ComputedRef<{
+        enableRemoteCall: boolean;
+        enableNvidiaVgpuModel: boolean;
+        enableNvidiaVgpuDevices: boolean;
+        assignGpuDisabled: boolean;
+        enableNvidiaVgpuPriority: boolean;
+        enableNvidiaVgpuSchedulePolicy: boolean;
+        nvidiaGpuModels: string[] | undefined;
+        nvidiaVgpuModelsAdaptor: {
+            data: import("../types").GPUSummary[];
+            loading: boolean;
+            refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
+        } | undefined;
+        nvidiaVgpuDevicesAdaptor: import("../props").GpuDevicesAdaptor | undefined;
+        isSide: boolean;
+    }>;
+    showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
+};
+export {};

package/dist/components/gpu/src/useGpuFormItemState.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const veeValidate = require("vee-validate");
+const props = require("../props.js");
+const types = require("../types.js");
+const utils = require("../utils.js");
+const gpuFormItem_mapper = require("./gpuFormItem.mapper.js");
+function useGpuFormItemState(props$1, emits, slots, i18nInstance) {
+  const {
+    values: quota,
+    setValues,
+    validate
+  } = veeValidate.useForm({
+    initialValues: {}
+  });
+  const dynamicQuota = vue.ref({});
+  const currentDisplayResource = vue.computed(() => {
+    var _a;
+    return (_a = props$1.getDisplayResource) == null ? void 0 : _a.call(props$1, quota.type ?? "");
+  });
+  const currentGpuProvider = vue.computed(() => {
+    var _a, _b;
+    return ((_b = (_a = props$1.gpuOptionsMap) == null ? void 0 : _a.get(quota.type ?? "")) == null ? void 0 : _b.provider) ?? "";
+  });
+  const openNvidiaAssignGpu = vue.ref(false);
+  const openNvidiaVgpuModel = vue.ref(false);
+  const openNvidiaVgpuSchedulePolicy = vue.ref(false);
+  const showDynamicForm = vue.computed(() => {
+    var _a, _b;
+    return (_b = (_a = props$1.gpuOptionsMap) == null ? void 0 : _a.get(quota.type ?? "")) == null ? void 0 : _b.isDynamic;
+  });
+  const gpuAdvancedFeatures = vue.computed(() => ({
+    enableNvidiaVgpuModel: props$1.enableNvidiaVgpuModel,
+    enableNvidiaVgpuDevices: props$1.enableNvidiaVgpuDevices,
+    enableNvidiaVgpuPriority: props$1.enableNvidiaVgpuPriority,
+    enableNvidiaVgpuSchedulePolicy: props$1.enableNvidiaVgpuSchedulePolicy
+  }));
+  const initValues = () => {
+    var _a;
+    const initialState = gpuFormItem_mapper.buildGpuFormItemInitialState({
+      quotaItem: props$1.quotaItem,
+      gpuOptionsMap: props$1.gpuOptionsMap ?? /* @__PURE__ */ new Map(),
+      advanced: gpuAdvancedFeatures.value
+    });
+    if (!initialState) {
+      return;
+    }
+    if (initialState.dynamicQuota) {
+      dynamicQuota.value = initialState.dynamicQuota;
+    }
+    openNvidiaAssignGpu.value = initialState.openNvidiaAssignGpu;
+    openNvidiaVgpuSchedulePolicy.value = initialState.openNvidiaVgpuSchedulePolicy;
+    if (!props$1.isSide) {
+      initialState.values.resources = {
+        ...gpuFormItem_mapper.buildGpuFormItemDefaultResources(
+          (_a = props$1.gpuOptionsMap) == null ? void 0 : _a.get(initialState.values.type ?? ""),
+          props$1.gpuUsage
+        ),
+        ...initialState.values.resources
+      };
+    }
+    setValues(initialState.values);
+  };
+  if (utils.isNvidiaVgpu(props$1.quotaItem.type ?? "")) {
+    initValues();
+  } else {
+    const unwatchInit = vue.watch(() => props$1.gpuOptionsMap, (newGpuOptions) => {
+      if (newGpuOptions == null ? void 0 : newGpuOptions.size) {
+        initValues();
+        setTimeout(() => {
+          unwatchInit == null ? void 0 : unwatchInit();
+        });
+      }
+    }, {
+      immediate: true
+    });
+  }
+  if (props$1.isSide) {
+    vue.watch(() => props$1.quotaItem, () => {
+      initValues();
+    }, {
+      deep: true
+    });
+  } else {
+    vue.watch([() => quota, dynamicQuota], () => {
+      emits("change", gpuFormItem_mapper.buildGpuFormItemChangePayload({
+        quota,
+        dynamicQuota: dynamicQuota.value,
+        quotaItem: props$1.quotaItem,
+        showDynamicForm: showDynamicForm.value,
+        advanced: gpuAdvancedFeatures.value,
+        openNvidiaAssignGpu: openNvidiaAssignGpu.value,
+        openNvidiaVgpuSchedulePolicy: openNvidiaVgpuSchedulePolicy.value
+      }));
+    }, {
+      deep: true
+    });
+  }
+  const filteredGpuOptionsMap = vue.computed(() => gpuFormItem_mapper.filterGpuFormItemOptions({
+    gpuOptionsMap: props$1.gpuOptionsMap ?? /* @__PURE__ */ new Map(),
+    quotaType: quota.type,
+    existTypes: props$1.existTypes,
+    targetType: props$1.targetType
+  }));
+  const priorityOpts = props.getPriorityOpts(i18nInstance);
+  const gpuAdvancedFormProps = vue.computed(() => ({
+    enableRemoteCall: props$1.enableRemoteCall,
+    enableNvidiaVgpuModel: props$1.enableNvidiaVgpuModel,
+    enableNvidiaVgpuDevices: props$1.enableNvidiaVgpuDevices,
+    assignGpuDisabled: props$1.assignGpuDisabled,
+    enableNvidiaVgpuPriority: props$1.enableNvidiaVgpuPriority,
+    enableNvidiaVgpuSchedulePolicy: props$1.enableNvidiaVgpuSchedulePolicy,
+    nvidiaGpuModels: props$1.nvidiaGpuModels,
+    nvidiaVgpuModelsAdaptor: props$1.nvidiaVgpuModelsAdaptor,
+    nvidiaVgpuDevicesAdaptor: props$1.nvidiaVgpuDevicesAdaptor,
+    isSide: props$1.isSide
+  }));
+  const isShowHamiGpuHelper = vue.computed(() => utils.isHamiGpu(currentGpuProvider.value) && props$1.gpuUsage === "workload" && !props$1.isSide);
+  const handleTypeChange = (val) => {
+    var _a;
+    quota.resources = gpuFormItem_mapper.buildGpuFormItemDefaultResources(
+      (_a = props$1.gpuOptionsMap) == null ? void 0 : _a.get(val),
+      props$1.gpuUsage
+    );
+    const isNextNvidiaVgpu = utils.isNvidiaVgpu(val);
+    if (gpuAdvancedFeatures.value.enableNvidiaVgpuPriority && isNextNvidiaVgpu) {
+      quota[types.nvidiaVgpuPriorityKey] = priorityOpts[0].value;
+    }
+    if (!isNextNvidiaVgpu && gpuAdvancedFeatures.value.enableNvidiaVgpuSchedulePolicy) {
+      openNvidiaVgpuSchedulePolicy.value = false;
+    }
+  };
+  const validateWrapper = () => {
+    if (props$1.isSide) {
+      return {
+        valid: true
+      };
+    }
+    return validate();
+  };
+  const gpuResourceHelperSlot = () => {
+    var _a;
+    return (_a = currentDisplayResource.value) == null ? void 0 : _a.reduce((acc, res) => {
+      const helperKey = `helper-${res.key}`;
+      if (slots[helperKey]) {
+        acc.push(helperKey);
+      }
+      return acc;
+    }, []);
+  };
+  const getGPUTypeInSide = (quotaType) => {
+    var _a;
+    if (!quotaType) {
+      return "";
+    }
+    return ((_a = filteredGpuOptionsMap.value.get(quotaType)) == null ? void 0 : _a.alias) ?? quotaType;
+  };
+  return {
+    quota,
+    dynamicQuota,
+    currentDisplayResource,
+    currentGpuProvider,
+    isShowHamiGpuHelper,
+    filteredGpuOptionsMap,
+    getGPUTypeInSide,
+    handleTypeChange,
+    validate: validateWrapper,
+    deSanitizeGPUObjectKey: utils.deSanitizeGPUObjectKey,
+    gpuResourceHelperSlot,
+    openNvidiaVgpuModel,
+    openNvidiaAssignGpu,
+    openNvidiaVgpuSchedulePolicy,
+    gpuAdvancedFormProps,
+    showDynamicForm
+  };
+}
+exports.useGpuFormItemState = useGpuFormItemState;