@cloud-ru/uikit-product-calculator 0.33.3 → 0.33.5

package/dist/esm/config/platforms/advanced/product-config/AdvancedPostgreSqlDatabase.js

@@ -0,0 +1,342 @@
+import { CONTROL } from '../../../../components';
+import { generateCpuItems, generateRamItems, getEip, getObs } from '../../../utils';
+import { getDisk } from '../../../utils/diskPostgreSqlMySQL';
+const BdInstanceTypeItem = {
+    Single: 'Single',
+    Replica: 'Replica',
+    PrimaryStandby: 'Primary/Standby',
+};
+const bdInstanceTypeItems = [
+    {
+        value: BdInstanceTypeItem.Single,
+        label: 'Single',
+        description: 'Одноузловая конфигурация',
+    },
+    {
+        value: BdInstanceTypeItem.PrimaryStandby,
+        label: 'Primary/Standby',
+        description: 'Отказоустойчивый кластер высокой доступности',
+    },
+];
+const BdEngineVersionItem = {
+    General_Purpose: 'General Purpose',
+    Dedicated: 'Dedicated',
+};
+const bdEngineVersionItems = [
+    {
+        value: BdEngineVersionItem.Dedicated,
+        label: 'Dedicated',
+        description: `Инстансы имеют выделенные ресурсы процессора`,
+    },
+    {
+        value: BdEngineVersionItem.General_Purpose,
+        label: 'General Purpose',
+        description: `Инстансы используют ресурсы процессора совместно с другими инстансами того же класса, размещенными на одном физическом сервере`,
+    },
+];
+const CpuRamByClassType = {
+    [BdEngineVersionItem.Dedicated]: {
+        [BdInstanceTypeItem.Single]: {
+            '2': [4, 8],
+            '4': [8, 16],
+            '8': [16, 32],
+            '16': [64],
+            '32': [128],
+            '64': [256],
+        },
+        [BdInstanceTypeItem.PrimaryStandby]: {
+            '2': [4, 8],
+            '4': [8, 16],
+            '8': [16, 32],
+            '16': [64],
+            '32': [128],
+            '64': [256],
+        },
+        [BdInstanceTypeItem.Replica]: {
+            '2': [4, 8],
+            '4': [8, 16],
+            '8': [16, 32],
+            '16': [64],
+            '32': [128],
+            '64': [256],
+        },
+    },
+    [BdEngineVersionItem.General_Purpose]: {
+        [BdInstanceTypeItem.Single]: {
+            '2': [4, 8],
+            '4': [8, 16],
+            '8': [16, 32],
+        },
+        [BdInstanceTypeItem.PrimaryStandby]: {
+            '2': [4, 8],
+            '4': [8, 16],
+            '8': [16, 32],
+        },
+        [BdInstanceTypeItem.Replica]: {
+            '2': [4, 8],
+            '4': [8, 16],
+            '8': [16, 32],
+        },
+    },
+};
+const getRdsControls = ({ prefix, }) => ({
+    cpu: {
+        type: CONTROL.Segmented,
+        accessorKey: `${prefix}.cpu`,
+        defaultValue: '2',
+        watchedControls: {
+            rdsBdEngineVersion: 'rds.bdInstanceClass',
+            rdsBdInstanceType: 'rds.bdInstanceType',
+        },
+        items: [],
+        decoratorProps: {
+            label: 'Количество vCPU',
+            labelTooltip: 'Виртуальный процессор',
+        },
+        relateFn: ({ rdsBdEngineVersion, rdsBdInstanceType, }) => {
+            var _a;
+            return ({
+                items: generateCpuItems((_a = Object.entries(CpuRamByClassType[rdsBdEngineVersion][rdsBdInstanceType]).map(([key]) => Number(key))) !== null && _a !== void 0 ? _a : []),
+            });
+        },
+    },
+    ram: {
+        type: CONTROL.Segmented,
+        accessorKey: `${prefix}.ram`,
+        defaultValue: '4',
+        items: [],
+        decoratorProps: {
+            label: 'Объём RAM',
+            labelTooltip: 'Оперативная память',
+        },
+        watchedControls: {
+            cpu: `${prefix}.cpu`,
+            rdsBdEngineVersion: 'rds.bdInstanceClass',
+            rdsBdInstanceType: 'rds.bdInstanceType',
+        },
+        relateFn: ({ cpu, rdsBdEngineVersion, rdsBdInstanceType, }) => {
+            var _a;
+            return ({
+                items: generateRamItems((_a = CpuRamByClassType[rdsBdEngineVersion][rdsBdInstanceType][cpu]) !== null && _a !== void 0 ? _a : []),
+            });
+        },
+    },
+    bdQuantity: {
+        type: CONTROL.Stepper,
+        accessorKey: `${prefix}.bdQuantity`,
+        defaultValue: 1,
+        decoratorProps: {
+            label: 'Количество баз данных',
+        },
+        uiProps: {
+            min: 1,
+            max: 50,
+            postfix: 'Шт',
+        },
+    },
+});
+const rds = getRdsControls({ prefix: 'rds' });
+const bdReplicaRds = getRdsControls({ prefix: 'bdReplica.rds' });
+export const POSTGRE_SQL_DATA_BASE_FORM_CONFIG = {
+    ui: [
+        'rdsBdEngineVersion',
+        'rdsBdInstanceType',
+        'bdInstanceAlert',
+        ['rdsCpu', 'rdsRam'],
+        ['evs', 'rdsBdQuantity'],
+        'bdReplica',
+        'eip',
+        ['obs'],
+    ],
+    controls: {
+        rdsBdEngineVersion: {
+            type: CONTROL.Carousel,
+            accessorKey: 'rds.bdInstanceClass',
+            defaultValue: BdEngineVersionItem.Dedicated,
+            items: bdEngineVersionItems,
+            decoratorProps: {
+                label: 'Класс инстанса',
+            },
+        },
+        rdsBdInstanceType: {
+            type: CONTROL.Carousel,
+            accessorKey: 'rds.bdInstanceType',
+            items: bdInstanceTypeItems,
+            defaultValue: BdInstanceTypeItem.Single,
+            decoratorProps: {
+                label: 'Режим развертывания',
+            },
+        },
+        bdInstanceAlert: {
+            type: 'alert',
+            uiProps: {
+                appearance: 'info',
+                description: 'Данный режим подразумевает развертывание на двух инстансах — Primary и Standby. Конфигурация инстанса Primary дублируется для инстанса Standby. Стоимость в чеке указывается за 2 инстанса',
+                outline: true,
+                visible: false,
+            },
+            accessorKey: 'instances',
+            watchedControls: { bdInstanceType: 'rds.bdInstanceType' },
+            relateFn: ({ bdInstanceType }) => {
+                if (bdInstanceType === BdInstanceTypeItem.PrimaryStandby) {
+                    return {
+                        uiProps: {
+                            visible: true,
+                        },
+                    };
+                }
+            },
+        },
+        bdReplica: {
+            type: CONTROL.Object,
+            ui: ['replica'],
+            visible: true,
+            controls: {
+                replica: {
+                    type: CONTROL.ToggleObject,
+                    switchKey: 'bdReplicaIsNeeded',
+                    decoratorProps: {
+                        label: 'Реплика базы данных',
+                        labelTooltip: 'Тип сервера реплики равен типу сервера базы данных',
+                    },
+                    control: {
+                        type: CONTROL.Object,
+                        ui: [
+                            ['cpu', 'ram'],
+                            ['systemDisk', 'bdQuantity'],
+                        ],
+                        controls: {
+                            cpu: Object.assign(Object.assign({}, bdReplicaRds.cpu), { decoratorProps: Object.assign(Object.assign({}, bdReplicaRds.cpu.decoratorProps), { labelTooltip: 'Количество vCPU реплики рекомендуется выбирать равное количеству основного RDS' }) }),
+                            ram: Object.assign(Object.assign({}, bdReplicaRds.ram), { decoratorProps: Object.assign(Object.assign({}, bdReplicaRds.ram.decoratorProps), { labelTooltip: 'Объем RAM реплики рекомендуется выбирать равное количеству основного RDS' }) }),
+                            bdQuantity: Object.assign(Object.assign({}, bdReplicaRds.bdQuantity), { accessorKey: 'bdReplica.replicaQuantity', decoratorProps: {
+                                    label: 'Количество реплик',
+                                }, uiProps: {
+                                    min: 1,
+                                    max: 5,
+                                    postfix: 'Шт',
+                                } }),
+                            systemDisk: getDisk({
+                                space: {
+                                    accessorKey: 'bdReplica.evs.systemDisk.diskSpace',
+                                    defaultValue: 40,
+                                    uiProps: {
+                                        min: 40,
+                                        max: 4000,
+                                        disabled: true,
+                                    },
+                                    decoratorProps: {
+                                        labelTooltip: 'SSD имеют высокую скорость передачи данных, что в два раза быстрее, чем HDD-накопители',
+                                    },
+                                },
+                                specification: {
+                                    accessorKey: 'bdReplica.evs.systemDisk.specification',
+                                    defaultValue: 'Cloud SSD',
+                                    uiProps: { disabled: true },
+                                },
+                            }),
+                            // Hidden
+                            replicaQuantity: {
+                                type: CONTROL.Stepper,
+                                accessorKey: 'bdReplica.rds.bdQuantity',
+                                defaultValue: 1,
+                                decoratorProps: {
+                                    label: '',
+                                },
+                                uiProps: {
+                                    visible: false,
+                                },
+                            },
+                            // Hidden
+                            evsAdditionalDisks: {
+                                type: 'select-multiple',
+                                accessorKey: 'bdReplica.evs.additionalDisks',
+                                items: [],
+                                defaultValue: [],
+                                uiProps: {
+                                    visible: false,
+                                },
+                                decoratorProps: {
+                                    label: '',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        rdsCpu: Object.assign(Object.assign({}, rds.cpu), { onChangeFn: (value, setValue) => {
+                setValue([
+                    ['rds.cpu', value],
+                    ['bdReplica.rds.cpu', value],
+                ]);
+            } }),
+        rdsRam: Object.assign(Object.assign({}, rds.ram), { onChangeFn: (value, setValue) => {
+                setValue([
+                    ['rds.ram', value],
+                    ['bdReplica.rds.ram', value],
+                ]);
+            } }),
+        rdsBdQuantity: rds.bdQuantity,
+        evs: getDisk({
+            space: {
+                accessorKey: 'evs.systemDisk.diskSpace',
+                defaultValue: 40,
+                uiProps: {
+                    min: 40,
+                    max: 4000,
+                },
+                onChangeFn: (value, setValue) => {
+                    setValue([
+                        ['evs.systemDisk.diskSpace', value],
+                        ['bdReplica.evs.systemDisk.diskSpace', value],
+                    ]);
+                },
+            },
+            specification: {
+                accessorKey: 'evs.systemDisk.specification',
+                defaultValue: 'Cloud SSD',
+                onChangeFn: (value, setValue) => {
+                    setValue([
+                        ['evs.systemDisk.specification', value],
+                        ['bdReplica.evs.systemDisk.specification', value],
+                    ]);
+                },
+            },
+        }),
+        eip: getEip({
+            trafficKey: 'eip.traffic',
+        }),
+        obs: getObs({
+            space: {
+                accessorKey: 'obs.storage.space',
+                defaultValue: 0,
+            },
+            units: {
+                accessorKey: 'obs.storage.unitsOfCalculation',
+            },
+        }),
+        // Hidden
+        evsAdditionalDisks: {
+            type: 'select-multiple',
+            accessorKey: 'evs.additionalDisks',
+            items: [],
+            defaultValue: [],
+            uiProps: {
+                visible: false,
+            },
+            decoratorProps: {
+                label: '',
+            },
+        },
+        // Hidden
+        ipQuantity: {
+            accessorKey: 'eip.ipQuantity',
+            type: CONTROL.Stepper,
+            defaultValue: 0,
+            decoratorProps: {},
+            uiProps: {
+                visible: false,
+            },
+        },
+    },
+};

package/dist/esm/config/platforms/advanced/product-config/AdvancedScalableFile.d.ts

@@ -0,0 +1,2 @@
+import { FormConfig } from '../../../../components';
+export declare const SCALABLE_FILE_FORM_CONFIG: FormConfig;

package/dist/esm/config/platforms/advanced/product-config/AdvancedScalableFile.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { CONTROL } from '../../../../components';
+import { getObs, UnitsOfCalculationItem } from '../../../utils';
+const StorageClassItem = {
+    Performance: 'Performance',
+    Standard: 'Standard',
+    StandardEnhanced: 'Standard-Enhanced',
+    PerformanceEnhanced: 'Performance-Enhanced',
+};
+const storageClassItems = [
+    {
+        value: StorageClassItem.Standard,
+        label: 'Standard',
+        description: (_jsxs(_Fragment, { children: ["150 M\u0411/\u0441; ", _jsx("br", {}), "\u041C\u0430\u043A\u0441. IOPS \u2014 5000; ", _jsx("br", {}), "\u0412\u0440\u0435\u043C\u044F \u0437\u0430\u0434\u0435\u0440\u0436\u043A\u0438: 2-5 \u043C\u0441; ", _jsx("br", {}), "\u041E\u0431\u044A\u0435\u043C \u043E\u0442 500 \u0413\u0411 \u0434\u043E 32 \u0422\u0411"] })),
+    },
+    {
+        value: StorageClassItem.Performance,
+        label: 'Performance',
+        description: (_jsxs(_Fragment, { children: ["300 M\u0411/\u0441; ", _jsx("br", {}), "\u041C\u0430\u043A\u0441. IOPS \u2014 20 000; ", _jsx("br", {}), "\u0412\u0440\u0435\u043C\u044F \u0437\u0430\u0434\u0435\u0440\u0436\u043A\u0438: 1-2 \u043C\u0441; ", _jsx("br", {}), "\u041E\u0431\u044A\u0435\u043C \u043E\u0442 500 \u0413\u0411 \u0434\u043E 32 \u0422\u0411"] })),
+    },
+    {
+        value: StorageClassItem.StandardEnhanced,
+        label: 'Standard-Enhanced',
+        description: (_jsxs(_Fragment, { children: ["1 \u0413\u0411/\u0441; ", _jsx("br", {}), "\u041C\u0430\u043A\u0441. IOPS \u2014 15 000; ", _jsx("br", {}), "\u0412\u0440\u0435\u043C\u044F \u0437\u0430\u0434\u0435\u0440\u0436\u043A\u0438: 2-5 \u043C\u0441; ", _jsx("br", {}), "\u041E\u0431\u044A\u0435\u043C \u043E\u0442 10 \u0422\u0411 \u0434\u043E 320 \u0422\u0411"] })),
+    },
+    {
+        value: StorageClassItem.PerformanceEnhanced,
+        label: 'Performance-Enhanced',
+        description: (_jsxs(_Fragment, { children: ["2 \u0413\u0411/\u0441; ", _jsx("br", {}), "\u041C\u0430\u043A\u0441. IOPS \u2014 100 000; ", _jsx("br", {}), "\u0412\u0440\u0435\u043C\u044F \u0437\u0430\u0434\u0435\u0440\u0436\u043A\u0438: 1-2 \u043C\u0441; ", _jsx("br", {}), "\u041E\u0431\u044A\u0435\u043C \u043E\u0442 10 \u0422\u0411 \u0434\u043E 320 \u0422\u0411"] })),
+    },
+];
+export const SCALABLE_FILE_FORM_CONFIG = {
+    ui: ['storageClass', ['storage']],
+    controls: {
+        storageClass: {
+            type: CONTROL.Carousel,
+            defaultValue: StorageClassItem.Standard,
+            items: storageClassItems,
+            accessorKey: 'sfs.storageClass',
+            decoratorProps: {
+                label: 'Класс хранилища',
+            },
+            onChangeFn: (value, setValue) => {
+                const arr = [
+                    ['sfs.storageClass', value],
+                    ['sfs.storage.unitsOfCalculation', UnitsOfCalculationItem.Gb],
+                ];
+                switch (value) {
+                    case StorageClassItem.StandardEnhanced:
+                    case StorageClassItem.PerformanceEnhanced: {
+                        arr.push(['sfs.storage.space', 10240]);
+                        break;
+                    }
+                    case StorageClassItem.Standard:
+                    case StorageClassItem.Performance:
+                    default: {
+                        arr.push(['sfs.storage.space', 500]);
+                        break;
+                    }
+                }
+                setValue(arr);
+            },
+        },
+        storage: getObs({
+            space: {
+                accessorKey: 'sfs.storage.space',
+                label: 'Размер хранилища',
+                defaultValue: 500,
+                uiProps: {
+                    min: 500,
+                    max: 32768,
+                    postfix: 'ГБ',
+                    showHint: true,
+                },
+                watchedControls: { storageClass: 'sfs.storageClass', specification: 'sfs.storage.unitsOfCalculation' },
+                relateFn: ({ storageClass, specification }) => {
+                    if (specification === 'tb') {
+                        if ([StorageClassItem.StandardEnhanced, StorageClassItem.PerformanceEnhanced].includes(storageClass)) {
+                            return {
+                                uiProps: {
+                                    min: 10,
+                                    max: 320,
+                                    postfix: 'ТБ',
+                                },
+                            };
+                        }
+                        return {
+                            uiProps: {
+                                min: 1,
+                                max: 32,
+                                postfix: 'ТБ',
+                            },
+                        };
+                    }
+                    if ([StorageClassItem.StandardEnhanced, StorageClassItem.PerformanceEnhanced].includes(storageClass)) {
+                        return {
+                            uiProps: {
+                                min: 10240,
+                                max: 327680,
+                                postfix: 'ГБ',
+                            },
+                        };
+                    }
+                },
+            },
+            units: {
+                accessorKey: 'sfs.storage.unitsOfCalculation',
+                defaultValue: 'gb',
+                onChangeFn: (value, setValue) => {
+                    const arr = [['sfs.storage.unitsOfCalculation', value]];
+                    if (value === UnitsOfCalculationItem.Tb) {
+                        arr.push(['sfs.storage.space', 1]);
+                    }
+                    setValue(arr);
+                },
+            },
+        }),
+    },
+};

package/dist/esm/config/platforms/advanced/product-config/AdvancedSqlDatabase.d.ts

@@ -0,0 +1,2 @@
+import { FormConfig } from '../../../../components';
+export declare const SQL_DATA_BASE_FORM_CONFIG: FormConfig;