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

package/dist/esm/config/platforms/vmware/products.d.ts

@@ -0,0 +1,2 @@
+import { CatalogConfig } from '../../../types';
+export declare const VM_WARE_PRODUCTS: CatalogConfig['products'];

package/dist/esm/config/platforms/vmware/products.js

@@ -0,0 +1,50 @@
+import { BackupSVG, VirtualDataCenterWithGpuSVG, VirtualDesktopInfrastructureSVG, VmBackupSVG, } from '@sbercloud/uikit-product-icons';
+import { PLATFORM } from '../../../constants';
+import { VM_WARE_PRODUCT } from './constants';
+import { VIRTUAL_DATA_CENTER_FORM_CONFIG, VM_WARE_CLOUD_BACKUP_FORM_CONFIG, VM_WARE_VIRTUAL_MACHINES_BACKUP_FORM_CONFIG, VM_WARE_VIRTUAL_WORKSPACES_FORM_CONFIG, } from './product-config';
+export const VM_WARE_PRODUCTS = {
+    [VM_WARE_PRODUCT.VmWareVirtualDataCenter]: {
+        id: VM_WARE_PRODUCT.VmWareVirtualDataCenter,
+        platform: PLATFORM.VmWare,
+        dataTestId: VM_WARE_PRODUCT.VmWareVirtualDataCenter,
+        label: 'VMware: Виртуальный ЦОД',
+        caption: 'Публичное облако на базе VMware',
+        formConfig: VIRTUAL_DATA_CENTER_FORM_CONFIG,
+        icon: VirtualDataCenterWithGpuSVG,
+        enableChangeProductQuantity: false,
+        hasPayaGo: true,
+    },
+    [VM_WARE_PRODUCT.VmWareCloudBackup]: {
+        id: VM_WARE_PRODUCT.VmWareCloudBackup,
+        platform: PLATFORM.VmWare,
+        dataTestId: VM_WARE_PRODUCT.VmWareCloudBackup,
+        label: 'VMware: резервное копирование в облако',
+        caption: 'Защита от потери данных, кибератак и сбоев приложений',
+        formConfig: VM_WARE_CLOUD_BACKUP_FORM_CONFIG,
+        icon: BackupSVG,
+        enableChangeProductQuantity: false,
+        hasPayaGo: true,
+    },
+    [VM_WARE_PRODUCT.VmWareVirtualMachinesBackup]: {
+        id: VM_WARE_PRODUCT.VmWareVirtualMachinesBackup,
+        platform: PLATFORM.VmWare,
+        dataTestId: VM_WARE_PRODUCT.VmWareVirtualMachinesBackup,
+        label: 'VMware: резервное копирование виртуальных машин',
+        caption: 'Сервис по созданию резервных копий, восстановлению виртуальных машин и отдельных файлов',
+        formConfig: VM_WARE_VIRTUAL_MACHINES_BACKUP_FORM_CONFIG,
+        icon: VmBackupSVG,
+        enableChangeProductQuantity: false,
+        hasPayaGo: true,
+    },
+    [VM_WARE_PRODUCT.VmWareVirtualWorkspaces]: {
+        id: VM_WARE_PRODUCT.VmWareVirtualWorkspaces,
+        platform: PLATFORM.VmWare,
+        dataTestId: VM_WARE_PRODUCT.VmWareVirtualWorkspaces,
+        label: 'VMware: Удаленные рабочие столы (VDI)',
+        caption: 'Виртуальные рабочие столы на платформе Облако VMware',
+        formConfig: VM_WARE_VIRTUAL_WORKSPACES_FORM_CONFIG,
+        icon: VirtualDesktopInfrastructureSVG,
+        enableChangeProductQuantity: false,
+        hasPayaGo: true,
+    },
+};

package/dist/esm/config/styles.module.css

@@ -0,0 +1,8 @@
+.tip{
+  margin:0;
+  padding:0 0 0 16px;
+  list-style-type:disc;
+}
+.tip li{
+  list-style-type:disc;
+}

package/dist/esm/config/utils/disk.d.ts

@@ -0,0 +1,25 @@
+import { ValueOf } from '@snack-uikit/utils';
+import { ObjectControl, SelectSingleControl, StepperControl } from '../../components';
+export declare const SpecificationItem: {
+    readonly HDD: "SAS";
+    readonly SSD: "SSD";
+    readonly ESSD: "ESSD";
+};
+export declare const specificationItems: ({
+    value: "SAS";
+    label: string;
+} | {
+    value: "SSD";
+    label: string;
+})[];
+type DiskSpecification = ValueOf<typeof SpecificationItem>;
+type GetDiskProps = {
+    space: Pick<Partial<StepperControl>, 'defaultValue' | 'accessorKey' | 'uiProps' | 'watchedControls' | 'relateFn' | 'onChangeFn' | 'decoratorProps'> & {
+        label?: string;
+    };
+    specification: Pick<Partial<SelectSingleControl>, 'accessorKey' | 'items' | 'uiProps' | 'watchedControls' | 'relateFn' | 'onChangeFn'> & {
+        defaultValue?: DiskSpecification;
+    };
+};
+export declare function getDisk({ space, specification }: GetDiskProps): ObjectControl;
+export {};

package/dist/esm/config/utils/disk.js

@@ -0,0 +1,41 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { CONTROL } from '../../components';
+export const SpecificationItem = {
+    HDD: 'SAS',
+    SSD: 'SSD',
+    ESSD: 'ESSD',
+};
+export const specificationItems = [
+    {
+        value: SpecificationItem.HDD,
+        label: 'HDD',
+    },
+    {
+        value: SpecificationItem.SSD,
+        label: 'SSD',
+    },
+];
+export function getDisk({ space, specification }) {
+    const { accessorKey: spaceKey = 'systemDisk.diskSpace', label: spaceLabel = 'Объем диска', uiProps: spaceUiProps, defaultValue: spaceDefaultValue = 0, decoratorProps: decoratorProps } = space, restSpace = __rest(space, ["accessorKey", "label", "uiProps", "defaultValue", "decoratorProps"]);
+    const { accessorKey: specificationKey = 'systemDisk.specification', items = specificationItems, uiProps: specificationUiProps, defaultValue: specificationDefaultValue = SpecificationItem.HDD } = specification, restSpecification = __rest(specification, ["accessorKey", "items", "uiProps", "defaultValue"]);
+    return {
+        type: 'object',
+        ui: [{ controls: ['space', 'specification'] }],
+        controls: {
+            space: Object.assign({ type: CONTROL.Stepper, decoratorProps: Object.assign({ label: spaceLabel }, decoratorProps), accessorKey: spaceKey, defaultValue: spaceDefaultValue, uiProps: Object.assign({ min: 0, max: 9999999999, postfix: 'ГБ' }, spaceUiProps) }, restSpace),
+            specification: Object.assign({ type: CONTROL.SelectSingle, decoratorProps: {
+                    label: '',
+                }, accessorKey: specificationKey, defaultValue: specificationDefaultValue, items: items, uiProps: Object.assign({ showClearButton: false, searchable: false }, specificationUiProps) }, restSpecification),
+        },
+    };
+}

package/dist/esm/config/utils/diskPostgreSqlMySQL.d.ts

@@ -0,0 +1,25 @@
+import { ValueOf } from '@snack-uikit/utils';
+import { ObjectControl, SelectSingleControl, StepperControl } from '../../components';
+export declare const SpecificationItem: {
+    readonly Extreme_SSD: "Extreme SSD";
+    readonly Cloud_SSD: "Cloud SSD";
+    readonly ESSD: "ESSD";
+};
+export declare const specificationItems: ({
+    value: "Extreme SSD";
+    label: string;
+} | {
+    value: "Cloud SSD";
+    label: string;
+})[];
+type DiskSpecification = ValueOf<typeof SpecificationItem>;
+type GetDiskProps = {
+    space: Pick<Partial<StepperControl>, 'defaultValue' | 'accessorKey' | 'uiProps' | 'watchedControls' | 'relateFn' | 'onChangeFn' | 'decoratorProps'> & {
+        label?: string;
+    };
+    specification: Pick<Partial<SelectSingleControl>, 'accessorKey' | 'items' | 'uiProps' | 'watchedControls' | 'relateFn' | 'onChangeFn'> & {
+        defaultValue?: DiskSpecification;
+    };
+};
+export declare function getDisk({ space, specification }: GetDiskProps): ObjectControl;
+export {};

package/dist/esm/config/utils/diskPostgreSqlMySQL.js

@@ -0,0 +1,41 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { CONTROL } from '../../components';
+export const SpecificationItem = {
+    Extreme_SSD: 'Extreme SSD',
+    Cloud_SSD: 'Cloud SSD',
+    ESSD: 'ESSD',
+};
+export const specificationItems = [
+    {
+        value: SpecificationItem.Extreme_SSD,
+        label: 'Extreme SSD',
+    },
+    {
+        value: SpecificationItem.Cloud_SSD,
+        label: 'Cloud SSD',
+    },
+];
+export function getDisk({ space, specification }) {
+    const { accessorKey: spaceKey = 'systemDisk.diskSpace', label: spaceLabel = 'Объем диска', uiProps: spaceUiProps, defaultValue: spaceDefaultValue = 0, decoratorProps: decoratorProps } = space, restSpace = __rest(space, ["accessorKey", "label", "uiProps", "defaultValue", "decoratorProps"]);
+    const { accessorKey: specificationKey = 'systemDisk.specification', items = specificationItems, uiProps: specificationUiProps, defaultValue: specificationDefaultValue = SpecificationItem.Cloud_SSD } = specification, restSpecification = __rest(specification, ["accessorKey", "items", "uiProps", "defaultValue"]);
+    return {
+        type: 'object',
+        ui: ['space', 'specification'],
+        controls: {
+            space: Object.assign({ type: CONTROL.Stepper, decoratorProps: Object.assign({ label: spaceLabel }, decoratorProps), accessorKey: spaceKey, defaultValue: spaceDefaultValue, uiProps: Object.assign({ min: 0, max: 9999999999, postfix: 'ГБ' }, spaceUiProps) }, restSpace),
+            specification: Object.assign({ type: CONTROL.SelectSingle, decoratorProps: {
+                    label: '',
+                }, accessorKey: specificationKey, defaultValue: specificationDefaultValue, items: items, uiProps: Object.assign({ showClearButton: false, searchable: false }, specificationUiProps) }, restSpecification),
+        },
+    };
+}

package/dist/esm/config/utils/eip.d.ts

@@ -0,0 +1,9 @@
+import { ToggleObjectControl } from '../../components';
+type GetEipProps = {
+    switchKey?: string;
+    velocityKey?: string;
+    trafficKey?: string;
+    specificationKey?: string;
+};
+export declare function getEip({ switchKey, velocityKey, trafficKey, specificationKey, }: GetEipProps): ToggleObjectControl;
+export {};

package/dist/esm/config/utils/eip.js

@@ -0,0 +1,89 @@
+import { CONTROL } from '../../components';
+const SpecificationItem = {
+    Velocity: 'velocity',
+    Traffic: 'traffic',
+};
+const specificationItems = [
+    {
+        value: SpecificationItem.Velocity,
+        label: 'Пропускная способность',
+    },
+    {
+        value: SpecificationItem.Traffic,
+        label: 'Количество трафика',
+    },
+];
+export function getEip({ switchKey = 'eipIsNeeded', velocityKey = 'eip.velocity', trafficKey = 'eip.trafficKey', specificationKey = 'eip.specification', }) {
+    return {
+        type: CONTROL.ToggleObject,
+        switchKey,
+        decoratorProps: {
+            label: 'Доступ в интернет',
+        },
+        control: {
+            type: CONTROL.Object,
+            ui: [['specification', 'velocity', 'traffic']],
+            controls: {
+                velocity: {
+                    type: CONTROL.Stepper,
+                    accessorKey: velocityKey,
+                    defaultValue: 100,
+                    decoratorProps: {
+                        label: 'Скорость',
+                        labelTooltip: 'Пропускная способность выделенной сети',
+                    },
+                    uiProps: {
+                        min: 1,
+                        max: 2000,
+                        step: 1,
+                        postfix: 'Mбит/сек',
+                    },
+                    watchedControls: { specification: specificationKey },
+                    relateFn: ({ specification }) => {
+                        if (specification === SpecificationItem.Traffic) {
+                            return {
+                                uiProps: {
+                                    visible: false,
+                                },
+                            };
+                        }
+                    },
+                },
+                traffic: {
+                    type: CONTROL.Stepper,
+                    accessorKey: trafficKey,
+                    defaultValue: 1,
+                    decoratorProps: {
+                        label: 'Количество трафика',
+                    },
+                    uiProps: {
+                        min: 1,
+                        max: 9999999999,
+                        showHint: false,
+                        postfix: 'ГБ',
+                        step: 1,
+                    },
+                    watchedControls: { specification: specificationKey },
+                    relateFn: ({ specification }) => {
+                        if (specification === SpecificationItem.Velocity) {
+                            return {
+                                uiProps: {
+                                    visible: false,
+                                },
+                            };
+                        }
+                    },
+                },
+                specification: {
+                    type: CONTROL.SelectSingle,
+                    accessorKey: specificationKey,
+                    defaultValue: SpecificationItem.Velocity,
+                    items: specificationItems,
+                    decoratorProps: {
+                        label: 'Способ тарификации доступа в интернет',
+                    },
+                },
+            },
+        },
+    };
+}

package/dist/esm/config/utils/index.d.ts

@@ -0,0 +1,26 @@
+import { WorkingHoursSpecification } from '../../constants';
+export declare const generateCpuItems: (items: number[]) => {
+    value: string;
+    label: string;
+}[];
+export declare const generateRamItems: (items: number[]) => {
+    value: string;
+    label: string;
+}[];
+export declare function generateInstanceConfigItems(items: [number, number][], valuesPostfixes?: [string, string]): {
+    value: string;
+    label: string;
+}[];
+export declare function generateBaseItems(arr: (string | number)[], labelReplacerFn?: (value: string) => string): {
+    value: string;
+    label: string;
+}[];
+export * from './disk';
+export * from './eip';
+export * from './obs';
+export declare const getNumeralWord: (value: number, words: string[]) => string;
+export declare const getMaxWorkingHoursAmount: (period: WorkingHoursSpecification, maxHours: {
+    hour: number;
+    day: number;
+    month: number;
+}) => number;

package/dist/esm/config/utils/index.js

@@ -0,0 +1,42 @@
+import { WorkingHoursSpecification } from '../../constants';
+export const generateCpuItems = (items) => items.map(item => ({ value: String(item), label: `${item} Шт` }));
+export const generateRamItems = (items) => items.map(item => ({ value: String(item), label: `${item} ГБ` }));
+export function generateInstanceConfigItems(items, valuesPostfixes) {
+    const { 0: fisrtPostfix = 'vCPU', 1: secondPostfix = 'ГБ RAM' } = valuesPostfixes !== null && valuesPostfixes !== void 0 ? valuesPostfixes : [];
+    return items.map(([cpu, ram]) => ({
+        value: [cpu, ram].join(' '),
+        label: `${cpu}${fisrtPostfix}, ${ram}${secondPostfix}`,
+    }));
+}
+export function generateBaseItems(arr, labelReplacerFn) {
+    return arr.map(item => ({
+        value: String(item),
+        label: labelReplacerFn ? labelReplacerFn(String(item)) : String(item),
+    }));
+}
+export * from './disk';
+export * from './eip';
+export * from './obs';
+export const getNumeralWord = (value, words) => {
+    const newValue = Math.abs(value) % 100;
+    const num = value % 10;
+    if (newValue > 10 && newValue < 20)
+        return words[2];
+    if (num > 1 && num < 5)
+        return words[1];
+    if (num === 1)
+        return words[0];
+    return words[2];
+};
+export const getMaxWorkingHoursAmount = (period, maxHours) => {
+    switch (period) {
+        case WorkingHoursSpecification.Hour:
+            return maxHours.hour;
+        case WorkingHoursSpecification.Day:
+            return maxHours.day;
+        case WorkingHoursSpecification.Month:
+            return maxHours.month;
+        default:
+            return 1;
+    }
+};

package/dist/esm/config/utils/obs.d.ts

@@ -0,0 +1,20 @@
+import { ValueOf } from '@snack-uikit/utils';
+import { ObjectControl, SelectSingleControl, StepperControl } from '../../components';
+export declare const UnitsOfCalculationItem: {
+    Gb: string;
+    Tb: string;
+};
+export declare const unitsOfCalculationItems: {
+    value: string;
+    label: string;
+}[];
+type GetObsProps = {
+    space: Pick<Partial<StepperControl>, 'defaultValue' | 'accessorKey' | 'uiProps' | 'watchedControls' | 'relateFn' | 'onChangeFn'> & {
+        label?: string;
+    };
+    units: Pick<Partial<SelectSingleControl>, 'accessorKey' | 'items' | 'uiProps' | 'watchedControls' | 'relateFn' | 'onChangeFn'> & {
+        defaultValue?: ValueOf<typeof UnitsOfCalculationItem>;
+    };
+};
+export declare function getObs({ space, units }: GetObsProps): ObjectControl;
+export {};

package/dist/esm/config/utils/obs.js

@@ -0,0 +1,51 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { CONTROL } from '../../components';
+export const UnitsOfCalculationItem = {
+    Gb: 'gb',
+    Tb: 'tb',
+};
+export const unitsOfCalculationItems = [
+    {
+        value: UnitsOfCalculationItem.Gb,
+        label: 'ГБ',
+    },
+    {
+        value: UnitsOfCalculationItem.Tb,
+        label: 'ТБ',
+    },
+];
+export function getObs({ space, units }) {
+    const { accessorKey: spaceKey = 'obs.space', label: spaceLabel = 'Объем хранилища', uiProps: spaceUiProps, defaultValue: spaceDefaultValue = 0 } = space, restSpace = __rest(space, ["accessorKey", "label", "uiProps", "defaultValue"]);
+    const { accessorKey: unitsKey = 'obs.unitsOfCalculation', items: unitsItems = unitsOfCalculationItems, uiProps: unitUiProps, defaultValue: unitsDefaultValue = UnitsOfCalculationItem.Gb } = units, restUnits = __rest(units, ["accessorKey", "items", "uiProps", "defaultValue"]);
+    return {
+        type: CONTROL.Object,
+        ui: [{ controls: ['space', 'unitsOfCalculation'] }],
+        controls: {
+            space: Object.assign({ type: CONTROL.Stepper, decoratorProps: {
+                    label: spaceLabel,
+                }, accessorKey: spaceKey, defaultValue: spaceDefaultValue, uiProps: Object.assign({ min: 0, max: 9999999900, postfix: 'ГБ', showHint: false }, spaceUiProps), watchedControls: { unitsOfCalculation: unitsKey }, relateFn: ({ unitsOfCalculation }) => {
+                    if (unitsOfCalculation === UnitsOfCalculationItem.Tb) {
+                        return {
+                            uiProps: {
+                                max: 9765620,
+                                postfix: 'ТБ',
+                            },
+                        };
+                    }
+                } }, restSpace),
+            unitsOfCalculation: Object.assign({ type: CONTROL.SelectSingle, accessorKey: unitsKey, decoratorProps: {
+                    label: '',
+                }, defaultValue: unitsDefaultValue, items: unitsItems, uiProps: Object.assign({ showClearButton: false, searchable: false }, unitUiProps) }, restUnits),
+        },
+    };
+}

package/dist/esm/constants.d.ts

@@ -0,0 +1,32 @@
+import { Price } from './types';
+export declare const PLATFORM: {
+    Advanced: string;
+    MlSpace: string;
+    VmWare: string;
+    Evolution: string;
+    Test: string;
+};
+export declare const DEFAULT_PRICE: Price;
+export declare const CATEGORY: {
+    readonly Popular: "popular";
+    readonly FreeTier: "free-tier";
+    readonly Computations: "computations";
+    readonly Network: "network";
+    readonly Containerization: "containerization";
+    readonly Storage: "storage";
+    readonly Database: "database";
+    readonly Development: "development";
+    readonly Analytic: "analytic";
+    readonly ML: "ml-ai-tools";
+};
+export declare const DEFAULT_CATEGORY: "popular";
+export declare const CALCULATOR_DATA_TEST_ID = "calculator";
+export declare enum WorkingHoursSpecification {
+    Hour = "hour",
+    Day = "day",
+    Month = "month"
+}
+export declare const WORKING_HOURS_ITEMS: {
+    value: WorkingHoursSpecification;
+    label: string;
+}[];

package/dist/esm/constants.js

@@ -0,0 +1,49 @@
+export const PLATFORM = {
+    Advanced: 'advanced',
+    MlSpace: 'mlspace',
+    VmWare: 'vmware',
+    Evolution: 'evolution',
+    Test: 'test',
+};
+export const DEFAULT_PRICE = {
+    priceHourNds: 0,
+    priceDayNds: 0,
+    priceMonthNds: 0,
+    pricePartnersHourNds: 0,
+    pricePartnersDayNds: 0,
+    pricePartnersMonthNds: 0,
+};
+export const CATEGORY = {
+    Popular: 'popular',
+    FreeTier: 'free-tier',
+    Computations: 'computations',
+    Network: 'network',
+    Containerization: 'containerization',
+    Storage: 'storage',
+    Database: 'database',
+    Development: 'development',
+    Analytic: 'analytic',
+    ML: 'ml-ai-tools',
+};
+export const DEFAULT_CATEGORY = CATEGORY.Popular;
+export const CALCULATOR_DATA_TEST_ID = 'calculator';
+export var WorkingHoursSpecification;
+(function (WorkingHoursSpecification) {
+    WorkingHoursSpecification["Hour"] = "hour";
+    WorkingHoursSpecification["Day"] = "day";
+    WorkingHoursSpecification["Month"] = "month";
+})(WorkingHoursSpecification || (WorkingHoursSpecification = {}));
+export const WORKING_HOURS_ITEMS = [
+    {
+        value: WorkingHoursSpecification.Month,
+        label: 'Месяц',
+    },
+    {
+        value: WorkingHoursSpecification.Day,
+        label: 'День',
+    },
+    {
+        value: WorkingHoursSpecification.Hour,
+        label: 'Час',
+    },
+];

package/dist/esm/contexts/CalculatorContext.d.ts

@@ -0,0 +1,35 @@
+import { PropsWithChildren } from 'react';
+import { LayoutType } from '@sbercloud/uikit-product-utils';
+import { CalculatorProps } from '../components';
+import { CatalogConfig, FetcherFn, FormValues, PlatformType, PricePeriod, ProductState } from '../types';
+import { CalculatorType } from '../types/CalculatorType';
+export type SelectedProduct = {
+    id: string;
+    idx: number;
+} | null;
+export type ProductsState = Record<string, ProductState[]>;
+type CalculatorContextType = {
+    selectedPlatform: PlatformType;
+    setSelectedPlatform(platform: PlatformType): void;
+    selectedCategory: string;
+    setSelectedCategory(category: string): void;
+    catalogOpen: boolean;
+    setCatalogOpen(open: boolean): void;
+    pricePeriod: PricePeriod;
+    setPricePeriod(period: PricePeriod): void;
+    selectedProduct: SelectedProduct;
+    setSelectedProduct(value: SelectedProduct): void;
+    layoutType: LayoutType;
+    calculatorType: CalculatorType;
+    config: CatalogConfig;
+    fetcherFn: FetcherFn;
+    products: ProductsState;
+    setProducts(products: FormValues): void;
+    actions: CalculatorProps['actions'];
+    onAnalyticsClick: NonNullable<CalculatorProps['onAnalyticsClick']>;
+};
+export declare const CalculatorContext: import("react").Context<CalculatorContextType>;
+export declare const useCalculatorContext: () => CalculatorContextType;
+type CalculatorContextProviderProps = PropsWithChildren<Pick<CalculatorProps, 'actions' | 'calculatorType' | 'fetcherFn' | 'iniState' | 'initialActiveProduct' | 'config' | 'layoutType' | 'onAnalyticsClick'>>;
+export declare function CalculatorContextProvider({ layoutType, calculatorType, fetcherFn, config, iniState, initialActiveProduct, actions, onAnalyticsClick, children, }: CalculatorContextProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/esm/contexts/CalculatorContext.js

@@ -0,0 +1,104 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState } from 'react';
+import { LAYOUT_TYPE } from '@sbercloud/uikit-product-utils';
+import { getDefaultValues } from '../components/Controls/utils';
+import { DEFAULT_CATEGORY, DEFAULT_PRICE, PLATFORM } from '../constants';
+import { PRICE_PERIOD } from '../types';
+import { CALCULATOR_TYPE } from '../types/CalculatorType';
+const noop = () => { };
+export const CalculatorContext = createContext({
+    selectedCategory: DEFAULT_CATEGORY,
+    setSelectedCategory: noop,
+    selectedPlatform: PLATFORM.Evolution,
+    setSelectedPlatform: noop,
+    catalogOpen: false,
+    setCatalogOpen: noop,
+    pricePeriod: PRICE_PERIOD.Month,
+    setPricePeriod: noop,
+    selectedProduct: null,
+    setSelectedProduct: noop,
+    calculatorType: CALCULATOR_TYPE.Main,
+    layoutType: LAYOUT_TYPE.Desktop,
+    config: {},
+    fetcherFn: (() => __awaiter(void 0, void 0, void 0, function* () { return undefined; })),
+    products: {},
+    setProducts: noop,
+    actions: {},
+    onAnalyticsClick: noop,
+});
+export const useCalculatorContext = () => useContext(CalculatorContext);
+export function CalculatorContextProvider({ layoutType = LAYOUT_TYPE.Desktop, calculatorType = CALCULATOR_TYPE.Main, fetcherFn, config, iniState, initialActiveProduct, actions, onAnalyticsClick, children, }) {
+    const [selectedPlatform, setSelectedPlatform] = useState(() => {
+        var _a;
+        if (initialActiveProduct) {
+            return (_a = config.products) === null || _a === void 0 ? void 0 : _a[initialActiveProduct].platform;
+        }
+        return config.platforms[0].id;
+    });
+    const [selectedCategory, setSelectedCategory] = useState(config.catalog[selectedPlatform][0].id);
+    const [selectedProduct, setSelectedProduct] = useState(() => {
+        if (iniState && Object.keys(iniState).length > 0) {
+            return { id: Object.keys(iniState)[0], idx: 0 };
+        }
+        if (initialActiveProduct) {
+            return { id: initialActiveProduct, idx: 0 };
+        }
+        return null;
+    });
+    const [open, setOpen] = useState(false);
+    const [pricePeriod, setPricePeriod] = useState(PRICE_PERIOD.Month);
+    const [products, setProducts] = useState(() => {
+        var _a;
+        if (iniState && Object.keys(iniState).length > 0) {
+            return iniState;
+        }
+        if (initialActiveProduct) {
+            const controls = (_a = config.products[initialActiveProduct].formConfig) === null || _a === void 0 ? void 0 : _a.controls;
+            if (controls) {
+                return {
+                    [initialActiveProduct]: [
+                        {
+                            data: Object.assign(Object.assign({}, getDefaultValues(controls !== null && controls !== void 0 ? controls : {})), { productQuantity: 1 }),
+                            price: DEFAULT_PRICE,
+                        },
+                    ],
+                };
+            }
+        }
+        return {};
+    });
+    const onAnalyticsClickCalculator = (value, control) => {
+        if (selectedProduct && onAnalyticsClick) {
+            onAnalyticsClick(value, `${control}-${selectedProduct.id}`);
+        }
+    };
+    return (_jsx(CalculatorContext.Provider, { value: {
+            selectedCategory,
+            setSelectedCategory,
+            selectedPlatform,
+            setSelectedPlatform,
+            pricePeriod,
+            setPricePeriod,
+            selectedProduct,
+            setSelectedProduct,
+            catalogOpen: open,
+            setCatalogOpen: setOpen,
+            layoutType,
+            calculatorType,
+            config,
+            fetcherFn,
+            products,
+            setProducts,
+            actions,
+            onAnalyticsClick: onAnalyticsClickCalculator,
+        }, children: children }));
+}