@dao-style/biz 0.6.0 → 0.7.0

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

@@ -0,0 +1,560 @@
+import type { GpuQuotaItem } from '../types';
+import type { GpuFormOptionsMap } from './gpuForm.internal-types';
+export declare function useGpuFormState(): {
+    rows: import("vue").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;
+    }[]>;
+    rowsRef: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            nvidiaVgpuModel: string;
+            nvidiaVgpuDevices: string[];
+            nvidiaVgpuGpuSchedule: import("../types").VgpuSchedulePolicy;
+            nvidiaVgpuNodeSchedule: import("../types").VgpuSchedulePolicy;
+            gpuSettingsAdaptor: import("..").GPUSettings;
+            nvidiaVgpuModelsAdaptor: {
+                data: import("../types").GPUSummary[];
+                loading: boolean;
+                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
+            };
+            nvidiaVgpuDevicesAdaptor: import("..").GpuDevicesAdaptor;
+            targetType: string;
+            gpuUsage: import("../types").GpuUsage;
+            enableRemoteCall: boolean;
+            enableRangeValidate: boolean;
+            enableNvidiaVgpuModel: boolean;
+            enableNvidiaVgpuDevices: boolean;
+            assignGpuDisabled: boolean;
+            enableNvidiaVgpuPriority: boolean;
+            nvidiaVgpuPriority: "0" | "1";
+            dynamicLimitOne: boolean;
+            enableNvidiaVgpuSchedulePolicy: boolean;
+            quotaItem: GpuQuotaItem;
+            isSide: boolean;
+            gpuProvider: string;
+            availableQuotaItem: GpuQuotaItem;
+            usedQuotaItem: GpuQuotaItem;
+            existTypes: string[];
+            nvidiaGpuDevices: import("..").GpuDevice[];
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            gpuSettingsAdaptor: {
+                type: import("vue").PropType<import("..").GPUSettings>;
+                default: undefined;
+            };
+            nvidiaVgpuModelsAdaptor: {
+                type: import("vue").PropType<{
+                    data: import("../types").GPUSummary[];
+                    loading: boolean;
+                    refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
+                }>;
+                default: undefined;
+            };
+            nvidiaVgpuDevicesAdaptor: {
+                type: import("vue").PropType<import("..").GpuDevicesAdaptor>;
+                default: undefined;
+            };
+            targetType: {
+                type: StringConstructor;
+                default: string;
+            };
+            gpuUsage: {
+                type: import("vue").PropType<import("../types").GpuUsage>;
+                default: string;
+            };
+            enableRemoteCall: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            enableRangeValidate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            enableNvidiaVgpuModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuModel: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            enableNvidiaVgpuDevices: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            assignGpuDisabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuDevices: {
+                type: import("vue").PropType<string[]>;
+                default: () => never[];
+            };
+            enableNvidiaVgpuPriority: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuPriority: {
+                type: import("vue").PropType<"0" | "1">;
+                default: undefined;
+            };
+            dynamicLimitOne: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            enableNvidiaVgpuSchedulePolicy: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuGpuSchedule: {
+                type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
+                default: undefined;
+            };
+            nvidiaVgpuNodeSchedule: {
+                type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
+                default: undefined;
+            };
+            quotaItem: {
+                type: import("vue").PropType<GpuQuotaItem>;
+                default: () => {};
+            };
+            isSide: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            gpuProvider: {
+                type: StringConstructor;
+                default: string;
+            };
+            availableQuotaItem: {
+                type: import("vue").PropType<GpuQuotaItem>;
+                default: undefined;
+            };
+            usedQuotaItem: {
+                type: import("vue").PropType<GpuQuotaItem>;
+                default: undefined;
+            };
+            existTypes: {
+                type: import("vue").PropType<string[]>;
+                default: () => never[];
+            };
+            gpuOptionsMap: {
+                type: import("vue").PropType<Map<string, import("../types").GPUSetting>>;
+                required: boolean;
+            };
+            nvidiaGpuModels: {
+                type: import("vue").PropType<string[]>;
+                required: boolean;
+            };
+            getDisplayResource: {
+                type: import("vue").PropType<(type: string) => import("../types").GPUResourceSetting[]>;
+                required: boolean;
+            };
+            nvidiaGpuDevices: {
+                type: import("vue").PropType<import("..").GpuDevice[]>;
+                default: () => never[];
+            };
+        }>> & {
+            onChange?: ((...args: any[]) => any) | undefined;
+            onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "nvidiaVgpuModel" | "nvidiaVgpuDevices" | "nvidiaVgpuGpuSchedule" | "nvidiaVgpuNodeSchedule" | "gpuSettingsAdaptor" | "nvidiaVgpuModelsAdaptor" | "nvidiaVgpuDevicesAdaptor" | "targetType" | "gpuUsage" | "enableRemoteCall" | "enableRangeValidate" | "enableNvidiaVgpuModel" | "enableNvidiaVgpuDevices" | "assignGpuDisabled" | "enableNvidiaVgpuPriority" | "nvidiaVgpuPriority" | "dynamicLimitOne" | "enableNvidiaVgpuSchedulePolicy" | "quotaItem" | "isSide" | "gpuProvider" | "availableQuotaItem" | "usedQuotaItem" | "existTypes" | "nvidiaGpuDevices">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
+        $emit: (event: "change" | "refreshGpuOptionsMap", ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            gpuSettingsAdaptor: {
+                type: import("vue").PropType<import("..").GPUSettings>;
+                default: undefined;
+            };
+            nvidiaVgpuModelsAdaptor: {
+                type: import("vue").PropType<{
+                    data: import("../types").GPUSummary[];
+                    loading: boolean;
+                    refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
+                }>;
+                default: undefined;
+            };
+            nvidiaVgpuDevicesAdaptor: {
+                type: import("vue").PropType<import("..").GpuDevicesAdaptor>;
+                default: undefined;
+            };
+            targetType: {
+                type: StringConstructor;
+                default: string;
+            };
+            gpuUsage: {
+                type: import("vue").PropType<import("../types").GpuUsage>;
+                default: string;
+            };
+            enableRemoteCall: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            enableRangeValidate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            enableNvidiaVgpuModel: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuModel: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            enableNvidiaVgpuDevices: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            assignGpuDisabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuDevices: {
+                type: import("vue").PropType<string[]>;
+                default: () => never[];
+            };
+            enableNvidiaVgpuPriority: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuPriority: {
+                type: import("vue").PropType<"0" | "1">;
+                default: undefined;
+            };
+            dynamicLimitOne: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            enableNvidiaVgpuSchedulePolicy: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            nvidiaVgpuGpuSchedule: {
+                type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
+                default: undefined;
+            };
+            nvidiaVgpuNodeSchedule: {
+                type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
+                default: undefined;
+            };
+            quotaItem: {
+                type: import("vue").PropType<GpuQuotaItem>;
+                default: () => {};
+            };
+            isSide: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            gpuProvider: {
+                type: StringConstructor;
+                default: string;
+            };
+            availableQuotaItem: {
+                type: import("vue").PropType<GpuQuotaItem>;
+                default: undefined;
+            };
+            usedQuotaItem: {
+                type: import("vue").PropType<GpuQuotaItem>;
+                default: undefined;
+            };
+            existTypes: {
+                type: import("vue").PropType<string[]>;
+                default: () => never[];
+            };
+            gpuOptionsMap: {
+                type: import("vue").PropType<Map<string, import("../types").GPUSetting>>;
+                required: boolean;
+            };
+            nvidiaGpuModels: {
+                type: import("vue").PropType<string[]>;
+                required: boolean;
+            };
+            getDisplayResource: {
+                type: import("vue").PropType<(type: string) => import("../types").GPUResourceSetting[]>;
+                required: boolean;
+            };
+            nvidiaGpuDevices: {
+                type: import("vue").PropType<import("..").GpuDevice[]>;
+                default: () => never[];
+            };
+        }>> & {
+            onChange?: ((...args: any[]) => any) | undefined;
+            onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
+        }, {
+            nvidiaVgpuModelKey: string;
+            nvidiaVgpuPriorityKey: string;
+            yup: typeof import("yup");
+            isNvidiaVgpu: (key?: string | undefined) => boolean;
+            isNvidiaMig: (key?: string | undefined) => boolean;
+            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 | undefined) => 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("..").GpuDevicesAdaptor | undefined;
+                isSide: boolean;
+            }>;
+            showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "refreshGpuOptionsMap")[], string, {
+            nvidiaVgpuModel: string;
+            nvidiaVgpuDevices: string[];
+            nvidiaVgpuGpuSchedule: import("../types").VgpuSchedulePolicy;
+            nvidiaVgpuNodeSchedule: import("../types").VgpuSchedulePolicy;
+            gpuSettingsAdaptor: import("..").GPUSettings;
+            nvidiaVgpuModelsAdaptor: {
+                data: import("../types").GPUSummary[];
+                loading: boolean;
+                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
+            };
+            nvidiaVgpuDevicesAdaptor: import("..").GpuDevicesAdaptor;
+            targetType: string;
+            gpuUsage: import("../types").GpuUsage;
+            enableRemoteCall: boolean;
+            enableRangeValidate: boolean;
+            enableNvidiaVgpuModel: boolean;
+            enableNvidiaVgpuDevices: boolean;
+            assignGpuDisabled: boolean;
+            enableNvidiaVgpuPriority: boolean;
+            nvidiaVgpuPriority: "0" | "1";
+            dynamicLimitOne: boolean;
+            enableNvidiaVgpuSchedulePolicy: boolean;
+            quotaItem: GpuQuotaItem;
+            isSide: boolean;
+            gpuProvider: string;
+            availableQuotaItem: GpuQuotaItem;
+            usedQuotaItem: GpuQuotaItem;
+            existTypes: string[];
+            nvidiaGpuDevices: import("..").GpuDevice[];
+        }, {}, string> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        gpuSettingsAdaptor: {
+            type: import("vue").PropType<import("..").GPUSettings>;
+            default: undefined;
+        };
+        nvidiaVgpuModelsAdaptor: {
+            type: import("vue").PropType<{
+                data: import("../types").GPUSummary[];
+                loading: boolean;
+                refresh: () => import("../types").GPUSummary[] | Promise<import("../types").GPUSummary[]>;
+            }>;
+            default: undefined;
+        };
+        nvidiaVgpuDevicesAdaptor: {
+            type: import("vue").PropType<import("..").GpuDevicesAdaptor>;
+            default: undefined;
+        };
+        targetType: {
+            type: StringConstructor;
+            default: string;
+        };
+        gpuUsage: {
+            type: import("vue").PropType<import("../types").GpuUsage>;
+            default: string;
+        };
+        enableRemoteCall: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        enableRangeValidate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        enableNvidiaVgpuModel: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nvidiaVgpuModel: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        enableNvidiaVgpuDevices: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        assignGpuDisabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nvidiaVgpuDevices: {
+            type: import("vue").PropType<string[]>;
+            default: () => never[];
+        };
+        enableNvidiaVgpuPriority: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nvidiaVgpuPriority: {
+            type: import("vue").PropType<"0" | "1">;
+            default: undefined;
+        };
+        dynamicLimitOne: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        enableNvidiaVgpuSchedulePolicy: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        nvidiaVgpuGpuSchedule: {
+            type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
+            default: undefined;
+        };
+        nvidiaVgpuNodeSchedule: {
+            type: import("vue").PropType<import("../types").VgpuSchedulePolicy>;
+            default: undefined;
+        };
+        quotaItem: {
+            type: import("vue").PropType<GpuQuotaItem>;
+            default: () => {};
+        };
+        isSide: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        gpuProvider: {
+            type: StringConstructor;
+            default: string;
+        };
+        availableQuotaItem: {
+            type: import("vue").PropType<GpuQuotaItem>;
+            default: undefined;
+        };
+        usedQuotaItem: {
+            type: import("vue").PropType<GpuQuotaItem>;
+            default: undefined;
+        };
+        existTypes: {
+            type: import("vue").PropType<string[]>;
+            default: () => never[];
+        };
+        gpuOptionsMap: {
+            type: import("vue").PropType<Map<string, import("../types").GPUSetting>>;
+            required: boolean;
+        };
+        nvidiaGpuModels: {
+            type: import("vue").PropType<string[]>;
+            required: boolean;
+        };
+        getDisplayResource: {
+            type: import("vue").PropType<(type: string) => import("../types").GPUResourceSetting[]>;
+            required: boolean;
+        };
+        nvidiaGpuDevices: {
+            type: import("vue").PropType<import("..").GpuDevice[]>;
+            default: () => never[];
+        };
+    }>> & {
+        onChange?: ((...args: any[]) => any) | undefined;
+        onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
+    } & import("vue").ShallowUnwrapRef<{
+        nvidiaVgpuModelKey: string;
+        nvidiaVgpuPriorityKey: string;
+        yup: typeof import("yup");
+        isNvidiaVgpu: (key?: string | undefined) => boolean;
+        isNvidiaMig: (key?: string | undefined) => boolean;
+        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 | undefined) => 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("..").GpuDevicesAdaptor | undefined;
+            isSide: boolean;
+        }>;
+        showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
+    }> & {} & import("vue").ComponentCustomProperties & {})[]>;
+    existTypes: import("vue").ComputedRef<string[]>;
+    updateRow: (idx: number, newRow: GpuQuotaItem) => void;
+    addRow: () => void;
+    removeRow: (idx: number) => void;
+    filterRows: (optionsMap: GpuFormOptionsMap) => void;
+    validate: () => Promise<{
+        valid: boolean;
+        message: string;
+    }>;
+};

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const gpuForm_constants = require("./gpuForm.constants.js");
+const gpuForm_mapper = require("./gpuForm.mapper.js");
+function useGpuFormState() {
+  const rows = 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 updateRow = (idx, newRow) => {
+    rows.value[idx] = newRow;
+  };
+  const addRow = () => {
+    rows.value.push(gpuForm_constants.createEmptyRow());
+  };
+  const removeRow = (idx) => {
+    rows.value.splice(idx, 1);
+  };
+  const filterRows = (optionsMap) => {
+    rows.value = gpuForm_mapper.filterGpuFormRows(rows.value, optionsMap);
+  };
+  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 };
+      })
+    );
+    const invalidResult = validsRes.find((result) => !result.valid);
+    const message = invalidResult && "errors" in invalidResult ? Object.values(invalidResult.errors ?? {}).find((error) => error == null ? void 0 : error.trim()) : void 0;
+    return {
+      valid: !invalidResult,
+      message: message ?? ""
+    };
+  };
+  return {
+    rows,
+    rowsRef,
+    existTypes,
+    updateRow,
+    addRow,
+    removeRow,
+    filterRows,
+    validate
+  };
+}
+exports.useGpuFormState = useGpuFormState;

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

@@ -0,0 +1,52 @@
+import { ref, computed } from "vue";
+import { createEmptyRow } from "./gpuForm.constants.mjs";
+import { filterGpuFormRows } from "./gpuForm.mapper.mjs";
+function useGpuFormState() {
+  const rows = ref([]);
+  const rowsRef = ref([]);
+  const existTypes = computed(() => rows.value.reduce((pre, row) => {
+    if (row.type) {
+      pre.push(row.type);
+    }
+    return pre;
+  }, []));
+  const updateRow = (idx, newRow) => {
+    rows.value[idx] = newRow;
+  };
+  const addRow = () => {
+    rows.value.push(createEmptyRow());
+  };
+  const removeRow = (idx) => {
+    rows.value.splice(idx, 1);
+  };
+  const filterRows = (optionsMap) => {
+    rows.value = filterGpuFormRows(rows.value, optionsMap);
+  };
+  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 };
+      })
+    );
+    const invalidResult = validsRes.find((result) => !result.valid);
+    const message = invalidResult && "errors" in invalidResult ? Object.values(invalidResult.errors ?? {}).find((error) => error == null ? void 0 : error.trim()) : void 0;
+    return {
+      valid: !invalidResult,
+      message: message ?? ""
+    };
+  };
+  return {
+    rows,
+    rowsRef,
+    existTypes,
+    updateRow,
+    addRow,
+    removeRow,
+    filterRows,
+    validate
+  };
+}
+export {
+  useGpuFormState
+};

package/dist/components/gpu/src/validations/nvidiaVgpuMemoryDecimal.d.ts

@@ -1,6 +1,10 @@
+type NvidiaVgpuMemoryDecimalOptions = {
+    isTouched?: () => boolean;
+};
 declare module 'yup' {
     interface NumberSchema {
-        nvidiaVgpuMemoryDecimal(message?: string): NumberSchema;
+        nvidiaVgpuMemoryDecimal(message?: string, options?: NvidiaVgpuMemoryDecimalOptions): NumberSchema;
     }
 }
 export default function register(i18n?: import("../../../../i18n").VueI18nLike | undefined): void;
+export {};

package/dist/components/gpu/style/assign-gpu-devices-list.d.ts

@@ -0,0 +1 @@
+import './assign-gpu-devices-list.scss';

package/dist/components/gpu/style/assign-gpu-devices-list.scss.js

@@ -0,0 +1,3 @@
+"use strict";
+const assignGpuDevicesList = "";
+module.exports = assignGpuDevicesList;