@dao-style/biz 0.6.0 → 0.7.0

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

@@ -0,0 +1,178 @@
+import { ref, computed, watch } from "vue";
+import { useForm } from "vee-validate";
+import { getPriorityOpts } from "../props.mjs";
+import { nvidiaVgpuPriorityKey } from "../types.mjs";
+import { isNvidiaVgpu, isHamiGpu, deSanitizeGPUObjectKey } from "../utils.mjs";
+import { buildGpuFormItemChangePayload, filterGpuFormItemOptions, buildGpuFormItemInitialState, buildGpuFormItemDefaultResources } from "./gpuFormItem.mapper.mjs";
+function useGpuFormItemState(props, emits, slots, i18nInstance) {
+  const {
+    values: quota,
+    setValues,
+    validate
+  } = useForm({
+    initialValues: {}
+  });
+  const dynamicQuota = ref({});
+  const currentDisplayResource = computed(() => {
+    var _a;
+    return (_a = props.getDisplayResource) == null ? void 0 : _a.call(props, quota.type ?? "");
+  });
+  const currentGpuProvider = computed(() => {
+    var _a, _b;
+    return ((_b = (_a = props.gpuOptionsMap) == null ? void 0 : _a.get(quota.type ?? "")) == null ? void 0 : _b.provider) ?? "";
+  });
+  const openNvidiaAssignGpu = ref(false);
+  const openNvidiaVgpuModel = ref(false);
+  const openNvidiaVgpuSchedulePolicy = ref(false);
+  const showDynamicForm = computed(() => {
+    var _a, _b;
+    return (_b = (_a = props.gpuOptionsMap) == null ? void 0 : _a.get(quota.type ?? "")) == null ? void 0 : _b.isDynamic;
+  });
+  const gpuAdvancedFeatures = computed(() => ({
+    enableNvidiaVgpuModel: props.enableNvidiaVgpuModel,
+    enableNvidiaVgpuDevices: props.enableNvidiaVgpuDevices,
+    enableNvidiaVgpuPriority: props.enableNvidiaVgpuPriority,
+    enableNvidiaVgpuSchedulePolicy: props.enableNvidiaVgpuSchedulePolicy
+  }));
+  const initValues = () => {
+    var _a;
+    const initialState = buildGpuFormItemInitialState({
+      quotaItem: props.quotaItem,
+      gpuOptionsMap: props.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.isSide) {
+      initialState.values.resources = {
+        ...buildGpuFormItemDefaultResources(
+          (_a = props.gpuOptionsMap) == null ? void 0 : _a.get(initialState.values.type ?? ""),
+          props.gpuUsage
+        ),
+        ...initialState.values.resources
+      };
+    }
+    setValues(initialState.values);
+  };
+  if (isNvidiaVgpu(props.quotaItem.type ?? "")) {
+    initValues();
+  } else {
+    const unwatchInit = watch(() => props.gpuOptionsMap, (newGpuOptions) => {
+      if (newGpuOptions == null ? void 0 : newGpuOptions.size) {
+        initValues();
+        setTimeout(() => {
+          unwatchInit == null ? void 0 : unwatchInit();
+        });
+      }
+    }, {
+      immediate: true
+    });
+  }
+  if (props.isSide) {
+    watch(() => props.quotaItem, () => {
+      initValues();
+    }, {
+      deep: true
+    });
+  } else {
+    watch([() => quota, dynamicQuota], () => {
+      emits("change", buildGpuFormItemChangePayload({
+        quota,
+        dynamicQuota: dynamicQuota.value,
+        quotaItem: props.quotaItem,
+        showDynamicForm: showDynamicForm.value,
+        advanced: gpuAdvancedFeatures.value,
+        openNvidiaAssignGpu: openNvidiaAssignGpu.value,
+        openNvidiaVgpuSchedulePolicy: openNvidiaVgpuSchedulePolicy.value
+      }));
+    }, {
+      deep: true
+    });
+  }
+  const filteredGpuOptionsMap = computed(() => filterGpuFormItemOptions({
+    gpuOptionsMap: props.gpuOptionsMap ?? /* @__PURE__ */ new Map(),
+    quotaType: quota.type,
+    existTypes: props.existTypes,
+    targetType: props.targetType
+  }));
+  const priorityOpts = getPriorityOpts(i18nInstance);
+  const gpuAdvancedFormProps = computed(() => ({
+    enableRemoteCall: props.enableRemoteCall,
+    enableNvidiaVgpuModel: props.enableNvidiaVgpuModel,
+    enableNvidiaVgpuDevices: props.enableNvidiaVgpuDevices,
+    assignGpuDisabled: props.assignGpuDisabled,
+    enableNvidiaVgpuPriority: props.enableNvidiaVgpuPriority,
+    enableNvidiaVgpuSchedulePolicy: props.enableNvidiaVgpuSchedulePolicy,
+    nvidiaGpuModels: props.nvidiaGpuModels,
+    nvidiaVgpuModelsAdaptor: props.nvidiaVgpuModelsAdaptor,
+    nvidiaVgpuDevicesAdaptor: props.nvidiaVgpuDevicesAdaptor,
+    isSide: props.isSide
+  }));
+  const isShowHamiGpuHelper = computed(() => isHamiGpu(currentGpuProvider.value) && props.gpuUsage === "workload" && !props.isSide);
+  const handleTypeChange = (val) => {
+    var _a;
+    quota.resources = buildGpuFormItemDefaultResources(
+      (_a = props.gpuOptionsMap) == null ? void 0 : _a.get(val),
+      props.gpuUsage
+    );
+    const isNextNvidiaVgpu = isNvidiaVgpu(val);
+    if (gpuAdvancedFeatures.value.enableNvidiaVgpuPriority && isNextNvidiaVgpu) {
+      quota[nvidiaVgpuPriorityKey] = priorityOpts[0].value;
+    }
+    if (!isNextNvidiaVgpu && gpuAdvancedFeatures.value.enableNvidiaVgpuSchedulePolicy) {
+      openNvidiaVgpuSchedulePolicy.value = false;
+    }
+  };
+  const validateWrapper = () => {
+    if (props.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,
+    gpuResourceHelperSlot,
+    openNvidiaVgpuModel,
+    openNvidiaAssignGpu,
+    openNvidiaVgpuSchedulePolicy,
+    gpuAdvancedFormProps,
+    showDynamicForm
+  };
+}
+export {
+  useGpuFormItemState
+};

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

@@ -0,0 +1,52 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { GpuQuota, GpuQuotaItem } from '../types';
+import type { GpuFormOptionsMap, GpuFormRows } from './gpuForm.internal-types';
+interface UseGpuFormSideStateParams {
+    usedQuota: ComputedRef<GpuQuota | undefined>;
+    availableQuota: ComputedRef<GpuQuota | undefined>;
+    gpuOptionsMap: ComputedRef<GpuFormOptionsMap> | Ref<GpuFormOptionsMap>;
+    withPrefixRequest: ComputedRef<boolean | undefined>;
+}
+export declare function useGpuFormSideState({ usedQuota, availableQuota, gpuOptionsMap, withPrefixRequest, }: UseGpuFormSideStateParams): {
+    sideRows: Ref<{
+        type?: string | undefined;
+        id?: string | undefined;
+        removable?: boolean | undefined;
+        resources?: Record<string, string | number | undefined> | undefined;
+        nvidiaVgpuModel?: string | undefined;
+        nvidiaVgpuDevices?: string[] | undefined;
+        nvidiaVgpPriority?: string | undefined;
+        nvidiaVgpuGpuSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+        nvidiaVgpuNodeSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+    }[]>;
+    showSide: ComputedRef<boolean>;
+    sideQuota: ComputedRef<GpuQuota | undefined>;
+    syncSideRowChange: (idx: number, newRow: GpuQuotaItem) => void;
+    syncSideRowAdd: () => void;
+    syncSideRowDelete: (idx: number) => void;
+    syncFilter: () => void;
+    initSideRows: (rows: GpuFormRows) => void;
+    getUsedQuotaItem: (index: number) => {
+        type?: string | undefined;
+        id?: string | undefined;
+        removable?: boolean | undefined;
+        resources?: Record<string, string | number | undefined> | undefined;
+        nvidiaVgpuModel?: string | undefined;
+        nvidiaVgpuDevices?: string[] | undefined;
+        nvidiaVgpPriority?: string | undefined;
+        nvidiaVgpuGpuSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+        nvidiaVgpuNodeSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+    } | undefined;
+    getAvailableQuotaItem: (index: number) => {
+        type?: string | undefined;
+        id?: string | undefined;
+        removable?: boolean | undefined;
+        resources?: Record<string, string | number | undefined> | undefined;
+        nvidiaVgpuModel?: string | undefined;
+        nvidiaVgpuDevices?: string[] | undefined;
+        nvidiaVgpPriority?: string | undefined;
+        nvidiaVgpuGpuSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+        nvidiaVgpuNodeSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+    } | undefined;
+};
+export {};

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const lodashEs = require("lodash-es");
+const gpuForm_mapper = require("./gpuForm.mapper.js");
+const gpuForm_constants = require("./gpuForm.constants.js");
+function useGpuFormSideState({
+  usedQuota,
+  availableQuota,
+  gpuOptionsMap,
+  withPrefixRequest
+}) {
+  const sideRows = vue.ref([]);
+  const sideQuota = vue.computed(() => usedQuota.value ?? availableQuota.value);
+  const showSide = vue.computed(() => !!sideQuota.value);
+  const syncSideRowChange = (idx, newRow) => {
+    if (!showSide.value) {
+      return;
+    }
+    sideRows.value[idx] = gpuForm_mapper.buildGpuFormSideRow({
+      row: lodashEs.cloneDeep(newRow),
+      gpuOptionsMap: gpuOptionsMap.value,
+      sideQuota: sideQuota.value,
+      withPrefixRequest: withPrefixRequest.value
+    });
+  };
+  const syncSideRowAdd = () => {
+    if (!showSide.value) {
+      return;
+    }
+    sideRows.value.push(gpuForm_constants.createEmptyRow());
+  };
+  const syncSideRowDelete = (idx) => {
+    if (sideRows.value.length) {
+      sideRows.value.splice(idx, 1);
+    }
+  };
+  const syncFilter = () => {
+    sideRows.value = gpuForm_mapper.filterGpuFormRows(sideRows.value, gpuOptionsMap.value);
+  };
+  const initSideRows = (rows) => {
+    sideRows.value = rows;
+  };
+  const getUsedQuotaItem = (index) => {
+    var _a;
+    if (usedQuota.value) {
+      return (_a = sideRows.value) == null ? void 0 : _a[index];
+    }
+    return void 0;
+  };
+  const getAvailableQuotaItem = (index) => {
+    var _a;
+    if (availableQuota.value) {
+      return (_a = sideRows.value) == null ? void 0 : _a[index];
+    }
+    return void 0;
+  };
+  return {
+    sideRows,
+    showSide,
+    sideQuota,
+    syncSideRowChange,
+    syncSideRowAdd,
+    syncSideRowDelete,
+    syncFilter,
+    initSideRows,
+    getUsedQuotaItem,
+    getAvailableQuotaItem
+  };
+}
+exports.useGpuFormSideState = useGpuFormSideState;

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

@@ -0,0 +1,71 @@
+import { ref, computed } from "vue";
+import { cloneDeep } from "lodash-es";
+import { buildGpuFormSideRow, filterGpuFormRows } from "./gpuForm.mapper.mjs";
+import { createEmptyRow } from "./gpuForm.constants.mjs";
+function useGpuFormSideState({
+  usedQuota,
+  availableQuota,
+  gpuOptionsMap,
+  withPrefixRequest
+}) {
+  const sideRows = ref([]);
+  const sideQuota = computed(() => usedQuota.value ?? availableQuota.value);
+  const showSide = computed(() => !!sideQuota.value);
+  const syncSideRowChange = (idx, newRow) => {
+    if (!showSide.value) {
+      return;
+    }
+    sideRows.value[idx] = buildGpuFormSideRow({
+      row: cloneDeep(newRow),
+      gpuOptionsMap: gpuOptionsMap.value,
+      sideQuota: sideQuota.value,
+      withPrefixRequest: withPrefixRequest.value
+    });
+  };
+  const syncSideRowAdd = () => {
+    if (!showSide.value) {
+      return;
+    }
+    sideRows.value.push(createEmptyRow());
+  };
+  const syncSideRowDelete = (idx) => {
+    if (sideRows.value.length) {
+      sideRows.value.splice(idx, 1);
+    }
+  };
+  const syncFilter = () => {
+    sideRows.value = filterGpuFormRows(sideRows.value, gpuOptionsMap.value);
+  };
+  const initSideRows = (rows) => {
+    sideRows.value = rows;
+  };
+  const getUsedQuotaItem = (index) => {
+    var _a;
+    if (usedQuota.value) {
+      return (_a = sideRows.value) == null ? void 0 : _a[index];
+    }
+    return void 0;
+  };
+  const getAvailableQuotaItem = (index) => {
+    var _a;
+    if (availableQuota.value) {
+      return (_a = sideRows.value) == null ? void 0 : _a[index];
+    }
+    return void 0;
+  };
+  return {
+    sideRows,
+    showSide,
+    sideQuota,
+    syncSideRowChange,
+    syncSideRowAdd,
+    syncSideRowDelete,
+    syncFilter,
+    initSideRows,
+    getUsedQuotaItem,
+    getAvailableQuotaItem
+  };
+}
+export {
+  useGpuFormSideState
+};