@escapenavigator/utils 2.0.48 → 2.0.50

package/dist/composition-price.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyCountsFromComposition = exports.legacyFromCategories = exports.compositionFromLegacy = exports.getMaxDiscountedSeats = exports.getCompositionPrice = exports.getCategorySeatPrice = exports.getCategorySeatDiscount = exports.getPerPersonAmount = exports.getLevelAmount = exports.getPricingHeads = exports.getTotalHeads = exports.normalizeComposition = exports.resolveCategories = exports.categoriesFromLegacy = exports.baseCategory = void 0;
+const tariff_category_mode_enum_1 = require("@escapenavigator/types/dist/tariff/enum/tariff-category-mode.enum");
+const tariff_reduced_rate_mode_enum_1 = require("@escapenavigator/types/dist/tariff/enum/tariff-reduced-rate-mode.enum");
+const tariff_category_1 = require("@escapenavigator/types/dist/tariff/tariff-category");
+const reduced_price_1 = require("./reduced-price");
+const int = (value) => {
+    const amount = Math.round(Number(value));
+    return Number.isFinite(amount) ? amount : 0;
+};
+const positiveInt = (value) => Math.max(0, int(value));
+/** Базисные пункты скидки: 1% = 100, потолок — 100%. */
+const clampBps = (value) => Math.min(10000, positiveInt(value));
+/**
+ * Базовая категория тарифа: полная доля групповой цены. Ровно одна на тариф —
+ * именно она задаёт «цену за человека», от которой считаются остальные.
+ */
+const baseCategory = (categories) => categories.find((category) => category.mode === tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE);
+exports.baseCategory = baseCategory;
+/**
+ * Категории тарифа, собранные из легаси-полей. Нужны, пока не все тарифы
+ * прошли бэкфилл и пока старые клиенты присылают тариф без `categories`.
+ *
+ * Соответствие точное, поэтому цена не меняется: льготная ставка — это
+ * категория, занимающая место в составе, а детская — надбавка сверх группы.
+ */
+const categoriesFromLegacy = (config) => {
+    const legacy = config.legacy || {};
+    const categories = [
+        {
+            key: tariff_category_1.BASE_CATEGORY_KEY,
+            title: '',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE,
+            value: 0,
+            countsInPrice: true,
+        },
+    ];
+    const reducedRate = positiveInt(legacy.reducedRate);
+    if (legacy.reducedRateMode && reducedRate > 0) {
+        categories.push({
+            key: tariff_category_1.REDUCED_CATEGORY_KEY,
+            title: legacy.reducedTitle || '',
+            description: legacy.reducedPriceDescription ?? null,
+            mode: legacy.reducedRateMode === tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.DELTA
+                ? tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA
+                : tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+            value: reducedRate,
+            countsInPrice: true,
+        });
+    }
+    const childPrice = config.price?.child;
+    if (childPrice !== undefined && childPrice !== null && !Number.isNaN(+childPrice)) {
+        categories.push({
+            key: tariff_category_1.CHILD_CATEGORY_KEY,
+            title: '',
+            description: legacy.childPriceDescription ?? null,
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+            value: positiveInt(childPrice),
+            countsInPrice: false,
+        });
+    }
+    return categories;
+};
+exports.categoriesFromLegacy = categoriesFromLegacy;
+/**
+ * Категории, по которым считать цену: собственные, если тариф уже переведён,
+ * иначе собранные из легаси-полей. Без базовой категории список бессмысленен
+ * (не от чего считать доли) — такой тоже уходит в легаси-ветку.
+ */
+const resolveCategories = (config) => {
+    const own = (config.categories || []).filter((category) => !!category?.key);
+    return own.length && (0, exports.baseCategory)(own) ? own : (0, exports.categoriesFromLegacy)(config);
+};
+exports.resolveCategories = resolveCategories;
+/** Нормализованный состав: целые неотрицательные числа, лишние ключи выброшены. */
+const normalizeComposition = (composition, categories) => {
+    const counts = {};
+    categories.forEach((category) => {
+        const count = positiveInt(composition?.[category.key]);
+        const max = category.max === null || category.max === undefined ? null : positiveInt(category.max);
+        counts[category.key] = max === null ? count : Math.min(count, max);
+    });
+    return counts;
+};
+exports.normalizeComposition = normalizeComposition;
+/** Гостей всего: и те, что занимают место в сетке, и надбавочные. */
+const getTotalHeads = (composition, categories) => categories.reduce((sum, category) => sum + positiveInt(composition?.[category.key]), 0);
+exports.getTotalHeads = getTotalHeads;
+/** Гостей, определяющих уровень сетки `price[N]`. */
+const getPricingHeads = (composition, categories) => categories.reduce((sum, category) => category.countsInPrice ? sum + positiveInt(composition?.[category.key]) : sum, 0);
+exports.getPricingHeads = getPricingHeads;
+/** Групповая цена уровня. 0 — состав недоступен для брони. */
+const getLevelAmount = (price, heads) => {
+    const amount = Number(price?.[heads]);
+    return Number.isFinite(amount) && amount > 0 ? amount : 0;
+};
+exports.getLevelAmount = getLevelAmount;
+/**
+ * Доля одного гостя в групповой цене. Не округляем: остаток от неровного
+ * деления (108 / 3) уходит в скидку места, а групповой итог остаётся ровно
+ * тем, что стоит в прайсе.
+ */
+const getPerPersonAmount = (price, heads) => {
+    const amount = (0, exports.getLevelAmount)(price, heads);
+    return amount && heads > 0 ? amount / heads : 0;
+};
+exports.getPerPersonAmount = getPerPersonAmount;
+/**
+ * Скидка одного гостя категории от базовой доли.
+ *
+ * Считаем именно скидку, а не цену гостя: групповой итог тогда остаётся
+ * суммой из прайса, а неровное деление не размазывается копейками по головам.
+ */
+const getCategorySeatDiscount = (category, perPerson) => {
+    switch (category.mode) {
+        case tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA:
+            return positiveInt(category.value);
+        case tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED:
+            // Ставка задана абсолютом: на больших группах обычная цена сама
+            // опускается до неё — тогда скидки нет.
+            return Math.max(0, Math.round(perPerson - positiveInt(category.value)));
+        case tariff_category_mode_enum_1.TariffCategoryModeEnum.PERCENT:
+            return Math.min(Math.round(perPerson), Math.round((perPerson * clampBps(category.value)) / 10000));
+        default:
+            return 0;
+    }
+};
+exports.getCategorySeatDiscount = getCategorySeatDiscount;
+/** Цена одного гостя категории при текущем составе. */
+const getCategorySeatPrice = (category, perPerson) => {
+    if (category.mode === tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED)
+        return positiveInt(category.value);
+    if (category.mode === tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE)
+        return Math.round(perPerson);
+    return Math.max(0, Math.round(perPerson) - (0, exports.getCategorySeatDiscount)(category, perPerson));
+};
+exports.getCategorySeatPrice = getCategorySeatPrice;
+/**
+ * Цена игры за состав.
+ *
+ * Сумма = цена уровня по головам, занимающим место, минус скидки этих голов,
+ * плюс надбавочные категории, и всё это не ниже минимальной стоимости игры.
+ */
+const getCompositionPrice = (source) => {
+    const categories = (0, exports.resolveCategories)(source);
+    const counts = (0, exports.normalizeComposition)(source.composition, categories);
+    const pricingHeads = (0, exports.getPricingHeads)(counts, categories);
+    const groupAmount = (0, exports.getLevelAmount)(source.price, pricingHeads);
+    const perPerson = pricingHeads > 0 ? groupAmount / pricingHeads : 0;
+    const addOn = categories.reduce((sum, category) => category.countsInPrice
+        ? sum
+        : sum + counts[category.key] * (0, exports.getCategorySeatPrice)(category, perPerson), 0);
+    // Цены на такой состав нет (или она 0 — «состав недоступен»). Минимальная
+    // стоимость игры к нему не применяется: иначе отключённое число игроков
+    // внезапно начало бы стоить пол выручки.
+    if (groupAmount <= 0)
+        return addOn;
+    const discount = categories.reduce((sum, category) => category.countsInPrice
+        ? sum + counts[category.key] * (0, exports.getCategorySeatDiscount)(category, perPerson)
+        : sum, 0);
+    return (0, reduced_price_1.applyMinGameAmount)(groupAmount - Math.min(discount, groupAmount) + addOn, source);
+};
+exports.getCompositionPrice = getCompositionPrice;
+/**
+ * Сколько гостей категории ещё снижают цену, не упираясь в пол выручки.
+ * Это не лимит выбора — отметить можно больше, цена просто перестанет падать.
+ */
+const getMaxDiscountedSeats = (source, categoryKey) => {
+    const categories = (0, exports.resolveCategories)(source);
+    const category = categories.find((item) => item.key === categoryKey);
+    if (!category?.countsInPrice)
+        return 0;
+    const counts = (0, exports.normalizeComposition)(source.composition, categories);
+    const pricingHeads = (0, exports.getPricingHeads)(counts, categories);
+    const groupAmount = (0, exports.getLevelAmount)(source.price, pricingHeads);
+    if (!groupAmount)
+        return 0;
+    const seatDiscount = (0, exports.getCategorySeatDiscount)(category, groupAmount / pricingHeads);
+    if (!seatDiscount)
+        return 0;
+    const room = groupAmount - (0, reduced_price_1.getMinGameAmount)(source);
+    if (room <= 0)
+        return 0;
+    return Math.min(pricingHeads, Math.floor(room / seatDiscount));
+};
+exports.getMaxDiscountedSeats = getMaxDiscountedSeats;
+/* ------------------------- Легаси-совместимость ------------------------- */
+/**
+ * Состав по категориям из полей старого формата.
+ *
+ * `reducedPlayers` — это часть `players`, поэтому базовой категории достаётся
+ * остаток. Обратное преобразование — `legacyCountsFromComposition`.
+ */
+const compositionFromLegacy = (legacyCounts, categories) => {
+    const players = positiveInt(legacyCounts.players);
+    const reduced = Math.min(positiveInt(legacyCounts.reducedPlayers), players);
+    const base = (0, exports.baseCategory)(categories);
+    const composition = {};
+    categories.forEach((category) => {
+        composition[category.key] = 0;
+    });
+    if (base)
+        composition[base.key] = players - reduced;
+    const reducedCategory = categories.find((category) => category.countsInPrice && category.mode !== tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE);
+    if (reducedCategory)
+        composition[reducedCategory.key] = reduced;
+    const childCategory = categories.find((category) => !category.countsInPrice);
+    if (childCategory)
+        composition[childCategory.key] = positiveInt(legacyCounts.children);
+    return composition;
+};
+exports.compositionFromLegacy = compositionFromLegacy;
+/**
+ * Легаси-поля тарифа, восстановленные из категорий. Обратная операция к
+ * `categoriesFromLegacy`: венью правит тариф уже категориями, а мобильное
+ * приложение и не обновлённые интеграции продолжают читать `price.child` и
+ * `reduced*` — без этой проекции они бы застыли на значениях до перехода.
+ *
+ * Схлопывание с потерями и это нормально: легаси-формат умеет ровно одну
+ * льготную категорию и ровно одну надбавочную. Берём первые — цена там, где
+ * есть `categories`, всё равно считается по ним.
+ */
+const legacyFromCategories = (categories, price) => {
+    const addOn = categories.find((category) => !category.countsInPrice);
+    const reduced = categories.find((category) => category.countsInPrice && category.mode !== tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE);
+    const legacy = {
+        childPrice: addOn ? positiveInt(addOn.value) : null,
+        childPriceDescription: addOn?.description ?? null,
+        reducedRateMode: null,
+        reducedRate: 0,
+        reducedTitle: reduced?.title || null,
+        reducedPriceDescription: reduced?.description ?? null,
+    };
+    if (!reduced)
+        return legacy;
+    if (reduced.mode === tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED) {
+        legacy.reducedRateMode = tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.FIXED;
+        legacy.reducedRate = positiveInt(reduced.value);
+        return legacy;
+    }
+    legacy.reducedRateMode = tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.DELTA;
+    if (reduced.mode === tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA) {
+        legacy.reducedRate = positiveInt(reduced.value);
+        return legacy;
+    }
+    // Процент в легаси-формате не выразить. Переводим в фиксированную скидку по
+    // самой большой группе: там доля гостя минимальна, значит и скидка выйдет
+    // наименьшей из возможных — старый клиент недосчитает скидку, но никогда не
+    // продаст игру дешевле, чем задумано.
+    const levels = Object.keys(price || {})
+        .map((key) => +key)
+        .filter((heads) => heads > 0 && (0, exports.getLevelAmount)(price, heads) > 0);
+    const largest = levels.length ? Math.max(...levels) : 0;
+    legacy.reducedRate = largest
+        ? (0, exports.getCategorySeatDiscount)(reduced, (0, exports.getPerPersonAmount)(price, largest))
+        : 0;
+    return legacy;
+};
+exports.legacyFromCategories = legacyFromCategories;
+/**
+ * Поля старого формата из состава по категориям. Нужны, пока их читают не
+ * обновлённые клиенты (мобильное приложение) и вся отчётность по броням.
+ *
+ * На тарифе с несколькими льготными категориями `reducedPlayers` схлопывает
+ * их в одно число: восстановить цену из легаси-полей в таком случае нельзя,
+ * источник истины — `composition` и снимок категорий на брони.
+ */
+const legacyCountsFromComposition = (composition, categories) => {
+    const counts = (0, exports.normalizeComposition)(composition, categories);
+    return categories.reduce((acc, category) => {
+        const count = counts[category.key];
+        if (!category.countsInPrice) {
+            acc.children += count;
+            return acc;
+        }
+        acc.players += count;
+        if (category.mode !== tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE)
+            acc.reducedPlayers += count;
+        return acc;
+    }, { players: 0, children: 0, reducedPlayers: 0 });
+};
+exports.legacyCountsFromComposition = legacyCountsFromComposition;

package/dist/composition-price.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composition-price.spec.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tariff_category_mode_enum_1 = require("@escapenavigator/types/dist/tariff/enum/tariff-category-mode.enum");
+const tariff_reduced_rate_mode_enum_1 = require("@escapenavigator/types/dist/tariff/enum/tariff-reduced-rate-mode.enum");
+const get_players_price_1 = require("./get-players-price");
+const composition_price_1 = require("./composition-price");
+/** Прайс реальной комнаты (Paris / Strange): база 98 € за двоих. */
+const PARIS = {
+    2: 9800,
+    3: 12000,
+    4: 14000,
+    5: 16000,
+    6: 18000,
+    7: 18900,
+    8: 20000,
+    9: 20700,
+    10: 22000,
+    11: 24200,
+    12: 26400,
+};
+const adults = {
+    key: 'adult',
+    title: 'Взрослые',
+    mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE,
+    value: 0,
+    countsInPrice: true,
+};
+describe('фиксированная скидка с человека', () => {
+    const students = {
+        key: 'student',
+        title: 'Студенты',
+        mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA,
+        value: 500,
+        countsInPrice: true,
+    };
+    const price = (adult, student) => (0, composition_price_1.getCompositionPrice)({
+        price: PARIS,
+        categories: [adults, students],
+        composition: { adult, student },
+        minGameAmount: 9800,
+    });
+    /**
+     * Льготная колонка венью целиком: суммы взяты из их прайс-листа. Раньше
+     * этот же результат давала связка `reducedRate` + `reducedPlayers` — так
+     * проверяем, что перевод на категории не сдвинул ни одной цены.
+     */
+    it.each([
+        [3, 10500],
+        [4, 12000],
+        [5, 13500],
+        [6, 15000],
+        [7, 15400],
+        [8, 16000],
+        [9, 16200],
+        [10, 17000],
+        [11, 18700],
+        [12, 20400],
+    ])('вся группа из %i студентов стоит %i', (heads, expected) => {
+        expect(price(0, heads)).toBe(expected);
+    });
+    it('смешанный состав считается по головам', () => {
+        // Четверо за 140 €, из них двое студентов по −5 €.
+        expect(price(2, 2)).toBe(13000);
+    });
+    it('состав определяет уровень сетки независимо от категорий', () => {
+        // 1 + 3 и 4 + 0 — один и тот же уровень price[4].
+        expect(price(1, 3)).toBe(14000 - 1500);
+        expect(price(4, 0)).toBe(14000);
+    });
+    it('на минимальной группе скидка упирается в пол и выбор не блокирует', () => {
+        expect(price(0, 2)).toBe(9800);
+        expect((0, composition_price_1.getMaxDiscountedSeats)({ price: PARIS, categories: [adults, students], composition: { adult: 0, student: 2 }, minGameAmount: 9800 }, 'student')).toBe(0);
+    });
+});
+describe('фиксированная цена за человека', () => {
+    // Прайс из письма венью: 88 € за двоих (он же минимум), 108 € за трёх.
+    const price = { 2: 8800, 3: 10800, 4: 12000 };
+    const reduced = {
+        key: 'reduced',
+        title: 'Школьники',
+        mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+        value: 2200,
+        countsInPrice: true,
+    };
+    const total = (adult, school) => (0, composition_price_1.getCompositionPrice)({
+        price,
+        categories: [adults, reduced],
+        composition: { adult, reduced: school },
+        minGameAmount: 8800,
+    });
+    it('на троих одно льготное место даёт 94 €', () => {
+        expect(total(2, 1)).toBe(9400);
+    });
+    it('на четверых льготными могут быть все — 88 €', () => {
+        expect(total(0, 4)).toBe(8800);
+    });
+    it('смешанный состав: 2 обычных по 30 € + 2 льготных по 22 €', () => {
+        expect(total(2, 2)).toBe(10400);
+    });
+    it('не даёт скидки там, где обычная цена уже опустилась до льготной', () => {
+        // На 10 человек доля и так 22 € — категория ничего не меняет.
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, reduced],
+            composition: { adult: 0, reduced: 10 },
+            minGameAmount: 9800,
+        })).toBe(22000);
+    });
+});
+describe('процентная скидка', () => {
+    const seniors = {
+        key: 'senior',
+        title: 'Пенсионеры',
+        mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.PERCENT,
+        value: 2000,
+        countsInPrice: true,
+    };
+    it('снимает свой процент с доли гостя', () => {
+        // price[4] = 140 €, доля 35 €, −20 % = 7 € с каждого пенсионера.
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, seniors],
+            composition: { adult: 3, senior: 1 },
+        })).toBe(13300);
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, seniors],
+            composition: { adult: 0, senior: 4 },
+        })).toBe(11200);
+    });
+    it('сто процентов делают гостя бесплатным, но место в сетке он занимает', () => {
+        const free = { ...seniors, value: 10000 };
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, free],
+            composition: { adult: 2, senior: 2 },
+        })).toBe(7000);
+    });
+    it('процент не уводит цену ниже минимальной стоимости игры', () => {
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, { ...seniors, value: 10000 }],
+            composition: { adult: 2, senior: 2 },
+            minGameAmount: 9800,
+        })).toBe(9800);
+    });
+});
+describe('категории сверх групповой цены', () => {
+    const kids = {
+        key: 'kid',
+        title: 'Дети до 7 лет',
+        mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+        value: 0,
+        countsInPrice: false,
+    };
+    it('бесплатные дети не платят и не двигают уровень сетки', () => {
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, kids],
+            composition: { adult: 4, kid: 3 },
+        })).toBe(14000);
+    });
+    it('платные дети идут надбавкой к цене группы', () => {
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, { ...kids, value: 1000 }],
+            composition: { adult: 4, kid: 2 },
+        })).toBe(16000);
+    });
+    it('недоступный состав не считается, но надбавка остаётся', () => {
+        // Уровня на 20 человек в прайсе нет: минимум к такому составу не
+        // применяется, иначе отключённое число игроков начало бы стоить денег.
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, { ...kids, value: 1000 }],
+            composition: { adult: 20, kid: 1 },
+            minGameAmount: 9800,
+        })).toBe(1000);
+    });
+});
+describe('смешанный состав из нескольких категорий', () => {
+    const categories = [
+        adults,
+        {
+            key: 'student',
+            title: 'Студенты',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA,
+            value: 500,
+            countsInPrice: true,
+        },
+        {
+            key: 'senior',
+            title: 'Пенсионеры',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.PERCENT,
+            value: 2500,
+            countsInPrice: true,
+        },
+        {
+            key: 'kid',
+            title: 'Дети до 7 лет',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+            value: 0,
+            countsInPrice: false,
+        },
+    ];
+    it('считает все категории в одной броне', () => {
+        // Уровень по головам в сетке = 2 + 1 + 1 = 4 → 140 €, доля 35 €.
+        // Студент −5 €, пенсионер −25 % = −8.75 → 9 €, ребёнок бесплатно.
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories,
+            composition: { adult: 2, student: 1, senior: 1, kid: 2 },
+        })).toBe(14000 - 500 - 875);
+    });
+    it('лимит категории режет состав', () => {
+        const limited = categories.map((category) => category.key === 'kid' ? { ...category, value: 1000, max: 1 } : category);
+        expect((0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: limited,
+            composition: { adult: 4, kid: 5 },
+        })).toBe(15000);
+    });
+});
+describe('совместимость с прежним форматом состава', () => {
+    const legacyTariff = {
+        price: { ...PARIS, child: 1000 },
+        legacy: {
+            reducedRateMode: tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.DELTA,
+            reducedRate: 500,
+            reducedTitle: 'Школьники',
+            childPriceDescription: 'До 7 лет',
+        },
+        minGameAmount: 9800,
+    };
+    it('тариф без категорий раскладывается на них автоматически', () => {
+        const categories = (0, composition_price_1.categoriesFromLegacy)(legacyTariff);
+        expect(categories.map((category) => [category.key, category.mode, category.countsInPrice]))
+            .toEqual([
+            ['adult', tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE, true],
+            ['reduced', tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA, true],
+            ['child', tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED, false],
+        ]);
+    });
+    it('старые поля состава дают ту же цену, что и категории', () => {
+        const legacyPrice = (0, get_players_price_1.getPlayersPrice)({
+            price: legacyTariff.price,
+            players: 4,
+            children: 2,
+            reducedPlayers: 2,
+            reducedRateMode: tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.DELTA,
+            reducedRate: 500,
+            minGameAmount: 9800,
+        });
+        expect(legacyPrice).toBe((0, composition_price_1.getCompositionPrice)({
+            ...legacyTariff,
+            categories: (0, composition_price_1.categoriesFromLegacy)(legacyTariff),
+            composition: { adult: 2, reduced: 2, child: 2 },
+        }));
+        expect(legacyPrice).toBe(14000 - 1000 + 2000);
+    });
+    it('состав переводится в старые поля и обратно без потерь', () => {
+        const categories = (0, composition_price_1.categoriesFromLegacy)(legacyTariff);
+        const composition = (0, composition_price_1.compositionFromLegacy)({ players: 4, children: 2, reducedPlayers: 3 }, categories);
+        expect(composition).toEqual({ adult: 1, reduced: 3, child: 2 });
+        expect((0, composition_price_1.legacyCountsFromComposition)(composition, categories)).toEqual({
+            players: 4,
+            children: 2,
+            reducedPlayers: 3,
+        });
+    });
+    it('несколько льготных категорий схлопываются в одно число льготных мест', () => {
+        const categories = [
+            adults,
+            { key: 'student', title: '', mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA, value: 500, countsInPrice: true },
+            { key: 'senior', title: '', mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.PERCENT, value: 2500, countsInPrice: true },
+        ];
+        expect((0, composition_price_1.legacyCountsFromComposition)({ adult: 1, student: 2, senior: 1 }, categories)).toEqual({ players: 4, children: 0, reducedPlayers: 3 });
+    });
+});
+describe('проекция категорий обратно в легаси-поля', () => {
+    const kids = {
+        key: 'kid',
+        title: 'До 7 лет',
+        description: 'Бесплатно',
+        mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+        value: 0,
+        countsInPrice: false,
+    };
+    it('надбавочная категория становится детской ценой тарифа', () => {
+        expect((0, composition_price_1.legacyFromCategories)([adults, kids], PARIS)).toMatchObject({
+            childPrice: 0,
+            childPriceDescription: 'Бесплатно',
+            reducedRateMode: null,
+            reducedRate: 0,
+        });
+    });
+    it('фикс и дельта переносятся один в один', () => {
+        const students = {
+            key: 'student',
+            title: 'Студенты',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA,
+            value: 500,
+            countsInPrice: true,
+        };
+        expect((0, composition_price_1.legacyFromCategories)([adults, students], PARIS)).toMatchObject({
+            reducedRateMode: tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.DELTA,
+            reducedRate: 500,
+            reducedTitle: 'Студенты',
+        });
+        expect((0, composition_price_1.legacyFromCategories)([adults, { ...students, mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED, value: 2200 }], PARIS)).toMatchObject({
+            reducedRateMode: tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.FIXED,
+            reducedRate: 2200,
+        });
+    });
+    it('процент превращается в самую осторожную фиксированную скидку', () => {
+        const seniors = {
+            key: 'senior',
+            title: 'Пенсионеры',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.PERCENT,
+            value: 2500,
+            countsInPrice: true,
+        };
+        // Доля гостя минимальна на группе из 12 (26400 / 12 = 2200), значит и
+        // 25% от неё — 550 — это наименьшая скидка, которую даёт эта строка.
+        // Старый клиент недосчитает скидку, но не продаст игру дешевле нужного.
+        const legacy = (0, composition_price_1.legacyFromCategories)([adults, seniors], PARIS);
+        expect(legacy).toMatchObject({
+            reducedRateMode: tariff_reduced_rate_mode_enum_1.TariffReducedRateModeEnum.DELTA,
+            reducedRate: 550,
+        });
+        const onSmallestGroup = (0, composition_price_1.getCompositionPrice)({
+            price: PARIS,
+            categories: [adults, seniors],
+            composition: { adult: 1, senior: 1 },
+        });
+        expect(onSmallestGroup).toBeLessThanOrEqual(9800 - legacy.reducedRate);
+    });
+    it('тариф без льготных строк обнуляет ставку, а не оставляет прежнюю', () => {
+        expect((0, composition_price_1.legacyFromCategories)([adults], PARIS)).toEqual({
+            childPrice: null,
+            childPriceDescription: null,
+            reducedRateMode: null,
+            reducedRate: 0,
+            reducedTitle: null,
+            reducedPriceDescription: null,
+        });
+    });
+});
+describe('цена строки категории', () => {
+    it('меняется вместе с составом — доля гостя падает на больших группах', () => {
+        const students = {
+            key: 'student',
+            title: '',
+            mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.DELTA,
+            value: 500,
+            countsInPrice: true,
+        };
+        expect((0, composition_price_1.getCategorySeatPrice)(adults, (0, composition_price_1.getPerPersonAmount)(PARIS, 2))).toBe(4900);
+        expect((0, composition_price_1.getCategorySeatPrice)(adults, (0, composition_price_1.getPerPersonAmount)(PARIS, 6))).toBe(3000);
+        expect((0, composition_price_1.getCategorySeatPrice)(students, (0, composition_price_1.getPerPersonAmount)(PARIS, 6))).toBe(2500);
+    });
+    it('на недоступном уровне цены нет', () => {
+        expect((0, composition_price_1.getPerPersonAmount)(PARIS, 20)).toBe(0);
+        expect((0, composition_price_1.getCategorySeatPrice)(adults, (0, composition_price_1.getPerPersonAmount)(PARIS, 20))).toBe(0);
+    });
+});