@dao-style/biz 0.6.0 → 0.7.0

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

@@ -0,0 +1,278 @@
+"use strict";
+const vue = require("vue");
+const extend = require("@dao-style/extend");
+const vueI18n = require("vue-i18n");
+const yup = require("yup");
+const veeValidate = require("vee-validate");
+const props = require("../../props.js");
+const utils = require("../../utils.js");
+const useSetFieldValue = require("../../../../utils/useSetFieldValue.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 hamiQuotaOverrideTypes = ["cores", "memory"];
+const mibPerGib = 1024;
+const vgpuMemoryUnits = ["Gi", "Mi"];
+const _sfc_main = vue.defineComponent({
+  name: "DaoGpuResources",
+  components: {
+    DaoFormItemValidate: extend.DaoFormItemValidate
+  },
+  props: props.gpuResourceItemProps,
+  setup(props$1) {
+    const isIluvatar = vue.computed(() => {
+      var _a, _b;
+      return (_b = (_a = props$1.quotaItem.type) == null ? void 0 : _a.toLocaleLowerCase) == null ? void 0 : _b.call(_a).includes("iluvatar");
+    });
+    const getIsIluvatarMemory = (alias) => isIluvatar.value && (alias == null ? void 0 : alias.includes("Memory"));
+    const isHami = vue.computed(() => utils.isHamiGpu(props$1.gpuProvider));
+    const isHamiQuota = vue.computed(() => isHami.value && props$1.gpuUsage === "quota");
+    const isVgpuMemoryResource = (resource) => {
+      var _a;
+      return isHami.value && resource.type === "memory" || props$1.quotaItem.type === props.nvidiaVgpuKey && ((_a = resource.alias) == null ? void 0 : _a.includes("Memory"));
+    };
+    const i18nInstance = vueI18n.useI18n();
+    const { t, locale } = i18nInstance;
+    const resourcePlaceholder = vue.computed(() => !props$1.enableRangeValidate ? t("biz.components.Gpu.unlimited") : "");
+    const getResHelper = (available, key, alias) => {
+      const resHelperList = [];
+      if ((available == null ? void 0 : available.available) && Number(available.available) > -1) {
+        resHelperList.push(t("biz.components.Gpu.available", {
+          available: available == null ? void 0 : available.available
+        }));
+      }
+      if (isIluvatar.value && (alias == null ? void 0 : alias.includes("Computing")) && alias.includes("Power")) {
+        resHelperList.push(t("biz.components.Gpu.iluvatar.computeTip"));
+      } else if (isIluvatar.value && (alias == null ? void 0 : alias.includes("Memory"))) {
+        resHelperList.push(t("biz.components.Gpu.iluvatar.memoryTip"));
+      }
+      return resHelperList.join(";");
+    };
+    const hamiQuotaDisplayKeys = {
+      cores: {
+        label: "biz.components.Gpu.hamiCoreQuota",
+        message: "biz.components.Gpu.hamiCoreQuotaTip"
+      },
+      memory: {
+        label: "biz.components.Gpu.hamiMemoryQuota",
+        message: "biz.components.Gpu.hamiMemoryQuotaTip"
+      }
+    };
+    const isHamiQuotaOverrideType = (type) => hamiQuotaOverrideTypes.includes(
+      type
+    );
+    const isHamiQuotaOverrideResource = (resource) => isHamiQuota.value && isHamiQuotaOverrideType(resource.type);
+    const getResIconMessage = (resource) => {
+      var _a;
+      if (isHamiQuotaOverrideResource(resource)) {
+        const messageKey = (_a = hamiQuotaDisplayKeys[resource.type]) == null ? void 0 : _a.message;
+        return messageKey ? t(messageKey) : resource.descriptionZh ?? resource.description ?? "";
+      }
+      return locale.value.includes("zh") && resource.descriptionZh || resource.description || "";
+    };
+    const getResLabel = (resource) => {
+      var _a;
+      if (isHamiQuotaOverrideResource(resource)) {
+        const labelKey = (_a = hamiQuotaDisplayKeys[resource.type]) == null ? void 0 : _a.label;
+        return labelKey ? t(labelKey) : resource.aliasZh ?? resource.alias ?? "";
+      }
+      return locale.value.includes("zh") && resource.aliasZh || resource.alias || "";
+    };
+    const getResRequired = (resource) => {
+      var _a, _b;
+      if (props$1.availableQuotaItem) {
+        const available = (_a = props$1.availableQuotaItem.resources) == null ? void 0 : _a[utils.sanitizeGPUKey((resource == null ? void 0 : resource.key) ?? "") ?? ""];
+        if (available !== void 0) {
+          return true;
+        }
+      }
+      if (!props$1.enableRangeValidate) {
+        return false;
+      }
+      return (((_b = resource.range) == null ? void 0 : _b.min) ?? 0) > 0;
+    };
+    const getResourceYup = (resource) => {
+      var _a, _b;
+      if (!props$1.enableRangeValidate) {
+        const { key } = resource;
+        const parsedKey = utils.sanitizeGPUKey(key);
+        if (props$1.availableQuotaItem) {
+          const available = (_a = props$1.availableQuotaItem.resources) == null ? void 0 : _a[parsedKey ?? ""];
+          if (available) {
+            return yup__namespace.number().integer().max(Number(available)).min(1);
+          }
+        }
+        if (props$1.usedQuotaItem) {
+          const used = (_b = props$1.usedQuotaItem.resources) == null ? void 0 : _b[parsedKey ?? ""];
+          if (used) {
+            return yup__namespace.number().integer().min(Number(used));
+          }
+        }
+        return yup__namespace.number().integer().min(1);
+      }
+      const { range } = resource;
+      if (range == null ? void 0 : range.max) {
+        return yup__namespace.number().integer().min((range == null ? void 0 : range.min) ?? 1).max(range.max);
+      }
+      return yup__namespace.number().integer().min((range == null ? void 0 : range.min) ?? 1);
+    };
+    const nvidiaVgpuMemoryResource = vue.computed(() => {
+      var _a;
+      return (_a = props$1.resources) == null ? void 0 : _a.find((res) => isVgpuMemoryResource(res));
+    });
+    const nvidiaVgpuMemoryField = vue.computed(() => {
+      var _a;
+      const key = (_a = nvidiaVgpuMemoryResource.value) == null ? void 0 : _a.key;
+      if (key) {
+        return `resources.${utils.sanitizeGPUKey(key)}`;
+      }
+      return "";
+    });
+    const nvidiaVgpuMemoryValue = veeValidate.useFieldValue(
+      nvidiaVgpuMemoryField
+    );
+    const setNvidiaVgpuMemoryValue = useSetFieldValue.useSetFieldValue(
+      nvidiaVgpuMemoryField
+    );
+    const validateNvidiaVgpuMemoryField = veeValidate.useValidateField(nvidiaVgpuMemoryField);
+    const normalizeMemoryValue = (value) => {
+      if (value === void 0 || value === null || value === "") {
+        return void 0;
+      }
+      const numberValue = Number(value);
+      return Number.isFinite(numberValue) ? numberValue : void 0;
+    };
+    const getMemoryDisplayUnit = (value) => {
+      const memoryValue = normalizeMemoryValue(value);
+      return memoryValue === void 0 || memoryValue % mibPerGib === 0 ? "Gi" : "Mi";
+    };
+    const initialMemoryValue = normalizeMemoryValue(nvidiaVgpuMemoryValue.value);
+    if (nvidiaVgpuMemoryResource.value && initialMemoryValue !== void 0 && typeof nvidiaVgpuMemoryValue.value !== "number") {
+      setNvidiaVgpuMemoryValue(initialMemoryValue);
+    }
+    const nvidiaVgpuMemoryUnitValue = vue.ref(
+      getMemoryDisplayUnit(initialMemoryValue)
+    );
+    const nvidiaVgpuMemoryUnit = vue.computed({
+      get: () => nvidiaVgpuMemoryUnitValue.value,
+      set(unit) {
+        if (unit === nvidiaVgpuMemoryUnitValue.value) {
+          return;
+        }
+        const memoryValue = normalizeMemoryValue(nvidiaVgpuMemoryValue.value);
+        if (unit === "Gi" && memoryValue !== void 0) {
+          const gibValue = Math.max(1, Math.round(memoryValue / mibPerGib));
+          setNvidiaVgpuMemoryValue(gibValue * mibPerGib);
+        }
+        nvidiaVgpuMemoryUnitValue.value = unit;
+        if (nvidiaVgpuMemoryField.value) {
+          validateNvidiaVgpuMemoryField();
+        }
+      }
+    });
+    const getQuotaResourceValue = (resource) => {
+      var _a, _b;
+      return (_b = (_a = props$1.quota) == null ? void 0 : _a.resources) == null ? void 0 : _b[utils.sanitizeGPUKey(resource.key) ?? ""];
+    };
+    const getSideResUnit = (resource) => {
+      if (isVgpuMemoryResource(resource)) {
+        return getMemoryDisplayUnit(getQuotaResourceValue(resource));
+      }
+      return resource.unit;
+    };
+    const getNvidiaVgpuMemoryResourceYup = (resource) => {
+      var _a, _b, _c, _d, _e, _f;
+      const schema = yup__namespace.number().integer().test({
+        name: "nvidiaVgpuMemoryUnitInteger",
+        message: t("biz.components.Gpu.numberIntegerError"),
+        test(value) {
+          return value == null || nvidiaVgpuMemoryUnit.value === "Mi" || Number.isInteger(value / mibPerGib);
+        }
+      });
+      const parsedKey = utils.sanitizeGPUKey(resource.key) ?? "";
+      const available = normalizeMemoryValue(
+        (_b = (_a = props$1.availableQuotaItem) == null ? void 0 : _a.resources) == null ? void 0 : _b[parsedKey]
+      );
+      const used = normalizeMemoryValue((_d = (_c = props$1.usedQuotaItem) == null ? void 0 : _c.resources) == null ? void 0 : _d[parsedKey]);
+      const minimums = [1];
+      const maximums = [];
+      if (available !== void 0) {
+        maximums.push(available);
+      }
+      if (used !== void 0) {
+        minimums.push(used);
+      }
+      if (props$1.enableRangeValidate) {
+        const rangeMin = normalizeMemoryValue((_e = resource.range) == null ? void 0 : _e.min);
+        const rangeMax = normalizeMemoryValue((_f = resource.range) == null ? void 0 : _f.max);
+        if (rangeMin !== void 0) {
+          minimums.push(rangeMin);
+        }
+        if (rangeMax !== void 0) {
+          maximums.push(rangeMax);
+        }
+      }
+      const schemaWithMinimum = schema.min(Math.max(...minimums));
+      return maximums.length > 0 ? schemaWithMinimum.max(Math.min(...maximums)) : schemaWithMinimum;
+    };
+    const nvidiaVgpuMemory = vue.computed({
+      get() {
+        const memoryValue = normalizeMemoryValue(nvidiaVgpuMemoryValue.value);
+        if (memoryValue === void 0) {
+          return void 0;
+        }
+        return nvidiaVgpuMemoryUnit.value === "Gi" ? memoryValue / mibPerGib : memoryValue;
+      },
+      set(v) {
+        if (v === void 0 || v === "") {
+          setNvidiaVgpuMemoryValue(void 0);
+        } else {
+          const memoryValue = Number(v) * (nvidiaVgpuMemoryUnit.value === "Gi" ? mibPerGib : 1);
+          setNvidiaVgpuMemoryValue(memoryValue);
+        }
+      }
+    });
+    const getSideValue = (resource) => {
+      const val = getQuotaResourceValue(resource);
+      if (isVgpuMemoryResource(resource) && val != null) {
+        const memoryValue = Number(val);
+        return getMemoryDisplayUnit(memoryValue) === "Gi" ? memoryValue / mibPerGib : memoryValue;
+      }
+      return val ?? "";
+    };
+    return {
+      getIsIluvatarMemory,
+      isVgpuMemoryResource,
+      getResHelper,
+      getSideResUnit,
+      resourcePlaceholder,
+      getResRequired,
+      nvidiaVgpuMemory,
+      vgpuMemoryUnits,
+      nvidiaVgpuMemoryUnit,
+      sanitizeGPUKey: utils.sanitizeGPUKey,
+      getResLabel,
+      getResIconMessage,
+      isHamiQuota,
+      yup: yup__namespace,
+      getResourceYup,
+      getNvidiaVgpuMemoryResourceYup,
+      getSideValue
+    };
+  }
+});
+module.exports = _sfc_main;

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

@@ -0,0 +1,262 @@
+import { defineComponent, computed, ref } from "vue";
+import { DaoFormItemValidate } from "@dao-style/extend";
+import { useI18n } from "vue-i18n";
+import * as yup from "yup";
+import { useFieldValue, useValidateField } from "vee-validate";
+import { gpuResourceItemProps, nvidiaVgpuKey } from "../../props.mjs";
+import { isHamiGpu, sanitizeGPUKey } from "../../utils.mjs";
+import { useSetFieldValue } from "../../../../utils/useSetFieldValue.mjs";
+const hamiQuotaOverrideTypes = ["cores", "memory"];
+const mibPerGib = 1024;
+const vgpuMemoryUnits = ["Gi", "Mi"];
+const _sfc_main = defineComponent({
+  name: "DaoGpuResources",
+  components: {
+    DaoFormItemValidate
+  },
+  props: gpuResourceItemProps,
+  setup(props) {
+    const isIluvatar = computed(() => {
+      var _a, _b;
+      return (_b = (_a = props.quotaItem.type) == null ? void 0 : _a.toLocaleLowerCase) == null ? void 0 : _b.call(_a).includes("iluvatar");
+    });
+    const getIsIluvatarMemory = (alias) => isIluvatar.value && (alias == null ? void 0 : alias.includes("Memory"));
+    const isHami = computed(() => isHamiGpu(props.gpuProvider));
+    const isHamiQuota = computed(() => isHami.value && props.gpuUsage === "quota");
+    const isVgpuMemoryResource = (resource) => {
+      var _a;
+      return isHami.value && resource.type === "memory" || props.quotaItem.type === nvidiaVgpuKey && ((_a = resource.alias) == null ? void 0 : _a.includes("Memory"));
+    };
+    const i18nInstance = useI18n();
+    const { t, locale } = i18nInstance;
+    const resourcePlaceholder = computed(() => !props.enableRangeValidate ? t("biz.components.Gpu.unlimited") : "");
+    const getResHelper = (available, key, alias) => {
+      const resHelperList = [];
+      if ((available == null ? void 0 : available.available) && Number(available.available) > -1) {
+        resHelperList.push(t("biz.components.Gpu.available", {
+          available: available == null ? void 0 : available.available
+        }));
+      }
+      if (isIluvatar.value && (alias == null ? void 0 : alias.includes("Computing")) && alias.includes("Power")) {
+        resHelperList.push(t("biz.components.Gpu.iluvatar.computeTip"));
+      } else if (isIluvatar.value && (alias == null ? void 0 : alias.includes("Memory"))) {
+        resHelperList.push(t("biz.components.Gpu.iluvatar.memoryTip"));
+      }
+      return resHelperList.join(";");
+    };
+    const hamiQuotaDisplayKeys = {
+      cores: {
+        label: "biz.components.Gpu.hamiCoreQuota",
+        message: "biz.components.Gpu.hamiCoreQuotaTip"
+      },
+      memory: {
+        label: "biz.components.Gpu.hamiMemoryQuota",
+        message: "biz.components.Gpu.hamiMemoryQuotaTip"
+      }
+    };
+    const isHamiQuotaOverrideType = (type) => hamiQuotaOverrideTypes.includes(
+      type
+    );
+    const isHamiQuotaOverrideResource = (resource) => isHamiQuota.value && isHamiQuotaOverrideType(resource.type);
+    const getResIconMessage = (resource) => {
+      var _a;
+      if (isHamiQuotaOverrideResource(resource)) {
+        const messageKey = (_a = hamiQuotaDisplayKeys[resource.type]) == null ? void 0 : _a.message;
+        return messageKey ? t(messageKey) : resource.descriptionZh ?? resource.description ?? "";
+      }
+      return locale.value.includes("zh") && resource.descriptionZh || resource.description || "";
+    };
+    const getResLabel = (resource) => {
+      var _a;
+      if (isHamiQuotaOverrideResource(resource)) {
+        const labelKey = (_a = hamiQuotaDisplayKeys[resource.type]) == null ? void 0 : _a.label;
+        return labelKey ? t(labelKey) : resource.aliasZh ?? resource.alias ?? "";
+      }
+      return locale.value.includes("zh") && resource.aliasZh || resource.alias || "";
+    };
+    const getResRequired = (resource) => {
+      var _a, _b;
+      if (props.availableQuotaItem) {
+        const available = (_a = props.availableQuotaItem.resources) == null ? void 0 : _a[sanitizeGPUKey((resource == null ? void 0 : resource.key) ?? "") ?? ""];
+        if (available !== void 0) {
+          return true;
+        }
+      }
+      if (!props.enableRangeValidate) {
+        return false;
+      }
+      return (((_b = resource.range) == null ? void 0 : _b.min) ?? 0) > 0;
+    };
+    const getResourceYup = (resource) => {
+      var _a, _b;
+      if (!props.enableRangeValidate) {
+        const { key } = resource;
+        const parsedKey = sanitizeGPUKey(key);
+        if (props.availableQuotaItem) {
+          const available = (_a = props.availableQuotaItem.resources) == null ? void 0 : _a[parsedKey ?? ""];
+          if (available) {
+            return yup.number().integer().max(Number(available)).min(1);
+          }
+        }
+        if (props.usedQuotaItem) {
+          const used = (_b = props.usedQuotaItem.resources) == null ? void 0 : _b[parsedKey ?? ""];
+          if (used) {
+            return yup.number().integer().min(Number(used));
+          }
+        }
+        return yup.number().integer().min(1);
+      }
+      const { range } = resource;
+      if (range == null ? void 0 : range.max) {
+        return yup.number().integer().min((range == null ? void 0 : range.min) ?? 1).max(range.max);
+      }
+      return yup.number().integer().min((range == null ? void 0 : range.min) ?? 1);
+    };
+    const nvidiaVgpuMemoryResource = computed(() => {
+      var _a;
+      return (_a = props.resources) == null ? void 0 : _a.find((res) => isVgpuMemoryResource(res));
+    });
+    const nvidiaVgpuMemoryField = computed(() => {
+      var _a;
+      const key = (_a = nvidiaVgpuMemoryResource.value) == null ? void 0 : _a.key;
+      if (key) {
+        return `resources.${sanitizeGPUKey(key)}`;
+      }
+      return "";
+    });
+    const nvidiaVgpuMemoryValue = useFieldValue(
+      nvidiaVgpuMemoryField
+    );
+    const setNvidiaVgpuMemoryValue = useSetFieldValue(
+      nvidiaVgpuMemoryField
+    );
+    const validateNvidiaVgpuMemoryField = useValidateField(nvidiaVgpuMemoryField);
+    const normalizeMemoryValue = (value) => {
+      if (value === void 0 || value === null || value === "") {
+        return void 0;
+      }
+      const numberValue = Number(value);
+      return Number.isFinite(numberValue) ? numberValue : void 0;
+    };
+    const getMemoryDisplayUnit = (value) => {
+      const memoryValue = normalizeMemoryValue(value);
+      return memoryValue === void 0 || memoryValue % mibPerGib === 0 ? "Gi" : "Mi";
+    };
+    const initialMemoryValue = normalizeMemoryValue(nvidiaVgpuMemoryValue.value);
+    if (nvidiaVgpuMemoryResource.value && initialMemoryValue !== void 0 && typeof nvidiaVgpuMemoryValue.value !== "number") {
+      setNvidiaVgpuMemoryValue(initialMemoryValue);
+    }
+    const nvidiaVgpuMemoryUnitValue = ref(
+      getMemoryDisplayUnit(initialMemoryValue)
+    );
+    const nvidiaVgpuMemoryUnit = computed({
+      get: () => nvidiaVgpuMemoryUnitValue.value,
+      set(unit) {
+        if (unit === nvidiaVgpuMemoryUnitValue.value) {
+          return;
+        }
+        const memoryValue = normalizeMemoryValue(nvidiaVgpuMemoryValue.value);
+        if (unit === "Gi" && memoryValue !== void 0) {
+          const gibValue = Math.max(1, Math.round(memoryValue / mibPerGib));
+          setNvidiaVgpuMemoryValue(gibValue * mibPerGib);
+        }
+        nvidiaVgpuMemoryUnitValue.value = unit;
+        if (nvidiaVgpuMemoryField.value) {
+          validateNvidiaVgpuMemoryField();
+        }
+      }
+    });
+    const getQuotaResourceValue = (resource) => {
+      var _a, _b;
+      return (_b = (_a = props.quota) == null ? void 0 : _a.resources) == null ? void 0 : _b[sanitizeGPUKey(resource.key) ?? ""];
+    };
+    const getSideResUnit = (resource) => {
+      if (isVgpuMemoryResource(resource)) {
+        return getMemoryDisplayUnit(getQuotaResourceValue(resource));
+      }
+      return resource.unit;
+    };
+    const getNvidiaVgpuMemoryResourceYup = (resource) => {
+      var _a, _b, _c, _d, _e, _f;
+      const schema = yup.number().integer().test({
+        name: "nvidiaVgpuMemoryUnitInteger",
+        message: t("biz.components.Gpu.numberIntegerError"),
+        test(value) {
+          return value == null || nvidiaVgpuMemoryUnit.value === "Mi" || Number.isInteger(value / mibPerGib);
+        }
+      });
+      const parsedKey = sanitizeGPUKey(resource.key) ?? "";
+      const available = normalizeMemoryValue(
+        (_b = (_a = props.availableQuotaItem) == null ? void 0 : _a.resources) == null ? void 0 : _b[parsedKey]
+      );
+      const used = normalizeMemoryValue((_d = (_c = props.usedQuotaItem) == null ? void 0 : _c.resources) == null ? void 0 : _d[parsedKey]);
+      const minimums = [1];
+      const maximums = [];
+      if (available !== void 0) {
+        maximums.push(available);
+      }
+      if (used !== void 0) {
+        minimums.push(used);
+      }
+      if (props.enableRangeValidate) {
+        const rangeMin = normalizeMemoryValue((_e = resource.range) == null ? void 0 : _e.min);
+        const rangeMax = normalizeMemoryValue((_f = resource.range) == null ? void 0 : _f.max);
+        if (rangeMin !== void 0) {
+          minimums.push(rangeMin);
+        }
+        if (rangeMax !== void 0) {
+          maximums.push(rangeMax);
+        }
+      }
+      const schemaWithMinimum = schema.min(Math.max(...minimums));
+      return maximums.length > 0 ? schemaWithMinimum.max(Math.min(...maximums)) : schemaWithMinimum;
+    };
+    const nvidiaVgpuMemory = computed({
+      get() {
+        const memoryValue = normalizeMemoryValue(nvidiaVgpuMemoryValue.value);
+        if (memoryValue === void 0) {
+          return void 0;
+        }
+        return nvidiaVgpuMemoryUnit.value === "Gi" ? memoryValue / mibPerGib : memoryValue;
+      },
+      set(v) {
+        if (v === void 0 || v === "") {
+          setNvidiaVgpuMemoryValue(void 0);
+        } else {
+          const memoryValue = Number(v) * (nvidiaVgpuMemoryUnit.value === "Gi" ? mibPerGib : 1);
+          setNvidiaVgpuMemoryValue(memoryValue);
+        }
+      }
+    });
+    const getSideValue = (resource) => {
+      const val = getQuotaResourceValue(resource);
+      if (isVgpuMemoryResource(resource) && val != null) {
+        const memoryValue = Number(val);
+        return getMemoryDisplayUnit(memoryValue) === "Gi" ? memoryValue / mibPerGib : memoryValue;
+      }
+      return val ?? "";
+    };
+    return {
+      getIsIluvatarMemory,
+      isVgpuMemoryResource,
+      getResHelper,
+      getSideResUnit,
+      resourcePlaceholder,
+      getResRequired,
+      nvidiaVgpuMemory,
+      vgpuMemoryUnits,
+      nvidiaVgpuMemoryUnit,
+      sanitizeGPUKey,
+      getResLabel,
+      getResIconMessage,
+      isHamiQuota,
+      yup,
+      getResourceYup,
+      getNvidiaVgpuMemoryResourceYup,
+      getSideValue
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/gpu/src/gpuForm.constants.d.ts

@@ -0,0 +1,3 @@
+import type { GpuQuotaItem } from '../types';
+export declare const gpuFormRowIdLength = 3;
+export declare const createEmptyRow: () => GpuQuotaItem;

package/dist/components/gpu/src/gpuForm.constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const randomStr = require("../../../utils/randomStr.js");
+const gpuFormRowIdLength = 3;
+const createEmptyRow = () => ({
+  id: randomStr.randomStr(gpuFormRowIdLength),
+  type: ""
+});
+exports.createEmptyRow = createEmptyRow;
+exports.gpuFormRowIdLength = gpuFormRowIdLength;

package/dist/components/gpu/src/gpuForm.constants.mjs

@@ -0,0 +1,10 @@
+import { randomStr } from "../../../utils/randomStr.mjs";
+const gpuFormRowIdLength = 3;
+const createEmptyRow = () => ({
+  id: randomStr(gpuFormRowIdLength),
+  type: ""
+});
+export {
+  createEmptyRow,
+  gpuFormRowIdLength
+};

package/dist/components/gpu/src/gpuForm.internal-types.d.ts

@@ -0,0 +1,49 @@
+import type { GPUResourceSetting, GPUSetting, GpuQuota, GpuQuotaItem, UpdateGpuQuota, VgpuSchedulePolicy } from '../types';
+export type GpuFormRows = GpuQuotaItem[];
+export type GpuFormVgpuExtraState = {
+    nvidiaVgpuModel?: string;
+    nvidiaVgpuDevices?: string[];
+    nvidiaVgpuPriority?: string;
+    nvidiaVgpuGpuSchedule?: VgpuSchedulePolicy;
+    nvidiaVgpuNodeSchedule?: VgpuSchedulePolicy;
+};
+export type GpuFormFormattedUpdate = {
+    change: UpdateGpuQuota;
+    vgpu: GpuFormVgpuExtraState;
+};
+export type GpuFormVgpuEmitProps = {
+    enableNvidiaVgpuModel?: boolean;
+    nvidiaVgpuModel?: string;
+    enableNvidiaVgpuDevices?: boolean;
+    nvidiaVgpuDevices?: string[];
+    enableNvidiaVgpuPriority?: boolean;
+    nvidiaVgpuPriority?: string;
+    enableNvidiaVgpuSchedulePolicy?: boolean;
+    nvidiaVgpuGpuSchedule?: VgpuSchedulePolicy;
+    nvidiaVgpuNodeSchedule?: VgpuSchedulePolicy;
+};
+export type GpuFormVgpuUpdateEmit = ['update:nvidiaVgpuModel', string | undefined] | ['update:nvidiaVgpuDevices', string[] | undefined] | ['update:nvidiaVgpuPriority', string | undefined] | ['update:nvidiaVgpuGpuSchedule', VgpuSchedulePolicy | undefined] | ['update:nvidiaVgpuNodeSchedule', VgpuSchedulePolicy | undefined];
+export type CreateGpuFormRowId = () => string;
+export type GpuFormOptionsMap = Map<string, GPUSetting>;
+export type GetGpuDisplayResource = (type: string) => GPUResourceSetting[];
+export type GpuFormInitialRowsParams = {
+    quota: GpuQuota;
+    availableQuota?: GpuQuota;
+    sideQuota?: GpuQuota;
+    gpuOptionsMap: GpuFormOptionsMap;
+    getDisplayResource: GetGpuDisplayResource;
+    withPrefixRequest?: boolean;
+    showSide?: boolean;
+    isLimitOne?: boolean;
+    vgpu?: GpuFormVgpuExtraState;
+};
+export type GpuFormInitialRowsResult = {
+    rows: GpuFormRows;
+    sideRows: GpuFormRows;
+};
+export type GpuFormSideRowParams = {
+    row: GpuQuotaItem;
+    gpuOptionsMap: GpuFormOptionsMap;
+    sideQuota?: GpuQuota;
+    withPrefixRequest?: boolean;
+};

package/dist/components/gpu/src/gpuForm.mapper.d.ts

@@ -0,0 +1,16 @@
+import type { GpuFormFormattedUpdate, GpuFormInitialRowsParams, GpuFormInitialRowsResult, GpuFormRows, GpuFormSideRowParams, GpuFormVgpuExtraState, GpuFormVgpuEmitProps, GpuFormVgpuUpdateEmit } from './gpuForm.internal-types';
+export declare const buildGpuFormFormattedUpdate: (rows: GpuFormRows, existTypes: string[], withPrefixRequest?: boolean) => GpuFormFormattedUpdate;
+export declare const filterGpuFormRows: (items: GpuFormRows, gpuOptionsMap: GpuFormSideRowParams['gpuOptionsMap']) => GpuFormRows;
+export declare const buildGpuFormVgpuUpdateEmits: (vgpu: GpuFormVgpuExtraState, props: GpuFormVgpuEmitProps, vgpuExist: boolean) => GpuFormVgpuUpdateEmit[];
+export declare const buildGpuFormSideRow: ({ row, gpuOptionsMap, sideQuota, withPrefixRequest, }: GpuFormSideRowParams) => {
+    type: string | undefined;
+    resources: {};
+    id?: string | undefined;
+    removable?: boolean | undefined;
+    nvidiaVgpuModel?: string | undefined;
+    nvidiaVgpuDevices?: string[] | undefined;
+    nvidiaVgpPriority?: string | undefined;
+    nvidiaVgpuGpuSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+    nvidiaVgpuNodeSchedule?: import("../types").VgpuSchedulePolicy | undefined;
+};
+export declare const buildGpuFormInitialRows: ({ quota, availableQuota, sideQuota, gpuOptionsMap, getDisplayResource, withPrefixRequest, showSide, isLimitOne, vgpu, }: GpuFormInitialRowsParams) => GpuFormInitialRowsResult;