@escapenavigator/utils 2.0.49 → 2.0.50

package/dist/composition-limits.d.ts

@@ -0,0 +1,63 @@
+import { OrderComposition, TariffCategory } from '@escapenavigator/types/dist/tariff/tariff-category';
+/**
+ * Границы выбора состава: до скольки можно докручивать каждую строку и можно
+ * ли текущий состав вообще оформить.
+ *
+ * Ключевая мысль — потолков два, и они независимы:
+ *  - вместимость комнаты ограничивает ВСЕХ гостей;
+ *  - сетка тарифа `price[N]` ограничивает только тех, кто входит в цену.
+ * Гость надбавочной категории (малыш до 7) занимает место в комнате, но на
+ * уровень `price[N]` не влияет — если считать его одним потолком, добавление
+ * малыша начинает отнимать место у взрослых.
+ *
+ * Второе: недоступный уровень внутри сетки (венью поставил 0 на «трёх») — это
+ * дырка, а не край. Через неё нужно уметь пройти к четверым, поэтому она не
+ * сужает границы, а лишь помечает состав как неоформляемый.
+ */
+export type CompositionLimitsSource = {
+    price?: Record<string, number> | null;
+    categories: TariffCategory[];
+    composition?: OrderComposition | null;
+    /** `questroom.playersMin`. Тарифный минимум всё равно сильнее. */
+    minPlayers?: number | null;
+    /** Вместимость: кап квеста и свободные места тикет-системы. */
+    maxPlayersLimit?: number | null;
+};
+export type CompositionLimits = {
+    /** Всего гостей влезает в комнату. */
+    capacityMax: number;
+    /** Гостей «в цене» — потолок сетки тарифа с учётом вместимости. */
+    pricingMax: number;
+    /** Гостей «в цене» — минимум, ниже которого игра не бронируется. */
+    effectiveMin: number;
+    pricingHeads: number;
+    totalHeads: number;
+    /** Уровни сетки с заданной ценой в пределах [effectiveMin, pricingMax]. */
+    availableLevels: number[];
+    /** Уровни для выбора числа тегами: влезают вместе с надбавочными гостями. */
+    baseLevelOptions: number[];
+    /** Состав внутри сетки, но цена на него не задана. */
+    levelUnavailable: boolean;
+    /** Гостей «в цене» не хватает на минимальную игру. */
+    belowMin: boolean;
+    /** Комната заполнена: «плюс» упёрся во вместимость. */
+    capacityReached: boolean;
+    /** Сетка цен исчерпана: «плюс» на платящих строках упёрся в тариф. */
+    pricingFull: boolean;
+    /** Состав можно оформить. */
+    bookable: boolean;
+    /** До скольки можно докрутить каждую строку. */
+    maxByCategory: Record<string, number>;
+};
+export declare const getCompositionLimits: ({ price, categories, composition, minPlayers, maxPlayersLimit, }: CompositionLimitsSource) => CompositionLimits;
+/**
+ * Состав торчит выше сетки — например, гость выбрал шестерых, а потом
+ * переключил вариацию, где цены есть только до четверых. Возвращает
+ * исправленный состав или `null`, если править нечего.
+ *
+ * Единственная автоправка состава, которая себя оправдывает: без неё на бэке
+ * `price[N]` = undefined → NaN → 500. Подтягивать состав к ближайшему
+ * доступному уровню в любую сторону — нельзя: для гостя это выглядит как
+ * «добавил подростка — отняло взрослого» и как «плюс не нажимается».
+ */
+export declare const clampCompositionToGrid: (source: CompositionLimitsSource) => OrderComposition | null;

package/dist/composition-limits.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clampCompositionToGrid = exports.getCompositionLimits = void 0;
+const tariff_category_mode_enum_1 = require("@escapenavigator/types/dist/tariff/enum/tariff-category-mode.enum");
+const composition_price_1 = require("./composition-price");
+const get_prices_1 = require("./get-prices");
+const positiveInt = (value) => {
+    const amount = Math.round(Number(value));
+    return Number.isFinite(amount) && amount > 0 ? amount : 0;
+};
+const getCompositionLimits = ({ price, categories, composition, minPlayers, maxPlayersLimit, }) => {
+    const levels = (0, get_prices_1.getPricesPlayersArray)(price || {}).map((key) => +key);
+    const maxFromTariff = levels.length ? levels[levels.length - 1] : 0;
+    const minFromTariff = levels.length ? levels[0] : 0;
+    const capacityMax = typeof maxPlayersLimit === 'number' && Number.isFinite(maxPlayersLimit)
+        ? Math.max(0, maxPlayersLimit)
+        : maxFromTariff;
+    const pricingMax = Math.min(maxFromTariff, capacityMax);
+    const effectiveMin = typeof minPlayers === 'number' && Number.isFinite(minPlayers)
+        ? Math.max(minFromTariff, minPlayers)
+        : minFromTariff;
+    const pricingHeads = (0, composition_price_1.getPricingHeads)(composition, categories);
+    const totalHeads = (0, composition_price_1.getTotalHeads)(composition, categories);
+    const addOnHeads = totalHeads - pricingHeads;
+    const availableLevels = Object.entries(price || {})
+        .filter(([key, amount]) => !Number.isNaN(+key) && Number(amount) > 0)
+        .map(([key]) => +key)
+        .filter((level) => level >= effectiveMin && level <= pricingMax)
+        .sort((left, right) => left - right);
+    const capacityRoom = Math.max(0, capacityMax - totalHeads);
+    const pricingRoom = Math.max(0, pricingMax - pricingHeads);
+    const maxByCategory = {};
+    categories.forEach((category) => {
+        const value = positiveInt(composition?.[category.key]);
+        const room = category.countsInPrice ? Math.min(capacityRoom, pricingRoom) : capacityRoom;
+        const own = category.max === null || category.max === undefined
+            ? Number.POSITIVE_INFINITY
+            : positiveInt(category.max);
+        maxByCategory[category.key] = Math.min(own, value + room);
+    });
+    const levelUnavailable = pricingHeads >= effectiveMin && (0, composition_price_1.getPerPersonAmount)(price, pricingHeads) === 0;
+    return {
+        capacityMax,
+        pricingMax,
+        effectiveMin,
+        pricingHeads,
+        totalHeads,
+        availableLevels,
+        baseLevelOptions: availableLevels.filter((level) => level + addOnHeads <= capacityMax),
+        levelUnavailable,
+        belowMin: totalHeads > 0 && pricingHeads < effectiveMin,
+        capacityReached: capacityMax > 0 && totalHeads >= capacityMax,
+        pricingFull: pricingMax > 0 && pricingHeads >= pricingMax,
+        bookable: totalHeads > 0 &&
+            pricingHeads >= effectiveMin &&
+            !levelUnavailable &&
+            totalHeads <= capacityMax,
+        maxByCategory,
+    };
+};
+exports.getCompositionLimits = getCompositionLimits;
+/**
+ * Состав торчит выше сетки — например, гость выбрал шестерых, а потом
+ * переключил вариацию, где цены есть только до четверых. Возвращает
+ * исправленный состав или `null`, если править нечего.
+ *
+ * Единственная автоправка состава, которая себя оправдывает: без неё на бэке
+ * `price[N]` = undefined → NaN → 500. Подтягивать состав к ближайшему
+ * доступному уровню в любую сторону — нельзя: для гостя это выглядит как
+ * «добавил подростка — отняло взрослого» и как «плюс не нажимается».
+ */
+const clampCompositionToGrid = (source) => {
+    const { pricingHeads, pricingMax } = (0, exports.getCompositionLimits)(source);
+    if (!pricingMax || pricingHeads <= pricingMax)
+        return null;
+    const base = source.categories.find((category) => category.mode === tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE);
+    if (!base)
+        return null;
+    const adjusted = positiveInt(source.composition?.[base.key]) - (pricingHeads - pricingMax);
+    if (adjusted < 0)
+        return null;
+    return { ...(source.composition || {}), [base.key]: adjusted };
+};
+exports.clampCompositionToGrid = clampCompositionToGrid;

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

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

package/dist/composition-limits.spec.js

@@ -0,0 +1,157 @@
+"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 composition_limits_1 = require("./composition-limits");
+const adults = {
+    key: 'adult',
+    title: 'Взрослые',
+    mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.BASE,
+    value: 0,
+    countsInPrice: true,
+};
+const teens = {
+    key: 'teen',
+    title: 'Подростки',
+    mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.PERCENT,
+    value: 2000,
+    countsInPrice: true,
+};
+/** Малыши: место в комнате занимают, на уровень `price[N]` не влияют. */
+const kids = {
+    key: 'kid',
+    title: 'До 7 лет',
+    mode: tariff_category_mode_enum_1.TariffCategoryModeEnum.FIXED,
+    value: 0,
+    countsInPrice: false,
+};
+const PRICE = { 2: 9800, 3: 12000, 4: 14000, 5: 16000, 6: 18000 };
+/** Венью закрыл игру на троих: цена 0 = «такой состав не продаём». */
+const PRICE_WITH_HOLE = { 2: 9800, 3: 0, 4: 14000, 5: 16000 };
+describe('надбавочные гости не отнимают места у платящих', () => {
+    it('малыш ест вместимость комнаты, но не место в сетке цен', () => {
+        const limits = (0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults, kids],
+            composition: { adult: 6, kid: 0 },
+            maxPlayersLimit: 8,
+        });
+        // Взрослых больше не добавить — сетка тарифа кончилась на шести.
+        expect(limits.maxByCategory.adult).toBe(6);
+        expect(limits.pricingFull).toBe(true);
+        // А малышей можно: в комнате ещё два места.
+        expect(limits.maxByCategory.kid).toBe(2);
+        expect(limits.capacityReached).toBe(false);
+        expect(limits.bookable).toBe(true);
+    });
+    it('добавленный малыш не сдвигает потолок взрослых', () => {
+        const withKid = (0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults, kids],
+            composition: { adult: 3, kid: 2 },
+            maxPlayersLimit: 8,
+        });
+        expect(withKid.pricingHeads).toBe(3);
+        expect(withKid.totalHeads).toBe(5);
+        expect(withKid.maxByCategory.adult).toBe(6);
+    });
+    it('вместимость режет всех, когда мест меньше, чем уровней тарифа', () => {
+        const limits = (0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults, kids],
+            composition: { adult: 3, kid: 1 },
+            maxPlayersLimit: 4,
+        });
+        expect(limits.capacityReached).toBe(true);
+        expect(limits.maxByCategory.adult).toBe(3);
+        expect(limits.maxByCategory.kid).toBe(1);
+    });
+});
+describe('закрытый уровень внутри сетки', () => {
+    const at = (composition) => (0, composition_limits_1.getCompositionLimits)({
+        price: PRICE_WITH_HOLE,
+        categories: [adults, teens],
+        composition,
+    });
+    it('его видно, но оформить нельзя', () => {
+        const limits = at({ adult: 2, teen: 1 });
+        expect(limits.pricingHeads).toBe(3);
+        expect(limits.levelUnavailable).toBe(true);
+        expect(limits.bookable).toBe(false);
+    });
+    it('сквозь него можно пройти к следующему рабочему составу', () => {
+        // Главное: «плюс» на закрытом уровне остаётся живым — взрослых можно
+        // докрутить до четырёх (это пятеро в цене, потолок сетки).
+        expect(at({ adult: 2, teen: 1 }).maxByCategory.adult).toBe(4);
+        expect(at({ adult: 3, teen: 1 }).levelUnavailable).toBe(false);
+        expect(at({ adult: 3, teen: 1 }).bookable).toBe(true);
+    });
+    it('в теги выбора числа закрытый уровень не попадает', () => {
+        expect(at({ adult: 2 }).baseLevelOptions).toEqual([2, 4, 5]);
+    });
+});
+describe('минимум и вместимость', () => {
+    it('одни малыши игру не составляют', () => {
+        const limits = (0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults, kids],
+            composition: { adult: 0, kid: 2 },
+        });
+        expect(limits.belowMin).toBe(true);
+        expect(limits.bookable).toBe(false);
+    });
+    it('пустой состав не считается ни бронируемым, ни ошибочным', () => {
+        const limits = (0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults, kids],
+            composition: {},
+        });
+        expect(limits.belowMin).toBe(false);
+        expect(limits.bookable).toBe(false);
+    });
+    it('минимум квеста сильнее тарифного, но не шире сетки', () => {
+        expect((0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults],
+            composition: { adult: 3 },
+            minPlayers: 4,
+        }).belowMin).toBe(true);
+        expect((0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults],
+            composition: { adult: 2 },
+            minPlayers: 1,
+        }).effectiveMin).toBe(2);
+    });
+    it('лимит категории не пробивается вместимостью', () => {
+        const limits = (0, composition_limits_1.getCompositionLimits)({
+            price: PRICE,
+            categories: [adults, { ...kids, max: 2 }],
+            composition: { adult: 2, kid: 1 },
+            maxPlayersLimit: 8,
+        });
+        expect(limits.maxByCategory.kid).toBe(2);
+    });
+});
+describe('состав выше сетки после смены вариации', () => {
+    it('опускается до нового потолка за счёт базовой категории', () => {
+        expect((0, composition_limits_1.clampCompositionToGrid)({
+            price: { 2: 9800, 3: 12000 },
+            categories: [adults, teens],
+            composition: { adult: 4, teen: 1 },
+        })).toEqual({ adult: 2, teen: 1 });
+    });
+    it('состав внутри сетки не трогается — даже на закрытом уровне', () => {
+        expect((0, composition_limits_1.clampCompositionToGrid)({
+            price: PRICE_WITH_HOLE,
+            categories: [adults, teens],
+            composition: { adult: 2, teen: 1 },
+        })).toBeNull();
+    });
+    it('не опускает базовую категорию ниже нуля', () => {
+        expect((0, composition_limits_1.clampCompositionToGrid)({
+            price: { 2: 9800 },
+            categories: [adults, teens],
+            composition: { adult: 0, teen: 5 },
+        })).toBeNull();
+    });
+});

package/dist/composition-price.d.ts

@@ -0,0 +1,128 @@
+import { TariffReducedRateModeEnum } from '@escapenavigator/types/dist/tariff/enum/tariff-reduced-rate-mode.enum';
+import { OrderComposition, TariffCategory } from '@escapenavigator/types/dist/tariff/tariff-category';
+/**
+ * Расчёт цены игры по составу, разложенному на категории участников.
+ *
+ * Категория — не абсолютный билет, а отношение к базовой доле группы
+ * (`price[уровень] / уровень`). Так сохраняется нелинейная сетка квестов:
+ * гость всегда дешевле в большой команде, и повышение цен не требует
+ * переписывать льготные колонки.
+ *
+ * Модуль заменяет `get-players-price` + `reduced-price` как источник истины;
+ * прежние поля (`players` / `children` / `reducedPlayers`) выражаются через
+ * категории адаптерами ниже и остаются в API ради не обновлённых клиентов.
+ */
+/** Конфиг тарифа в терминах, от которых зависит цена игры. */
+export type CompositionPricingConfig = {
+    price?: Record<string, number> | null;
+    /** Пусто — категории собираются из легаси-полей (`legacy` ниже). */
+    categories?: TariffCategory[] | null;
+    minGameAmount?: number | null;
+    /** Легаси-описание состава — используется, только если `categories` пуст. */
+    legacy?: {
+        reducedRateMode?: TariffReducedRateModeEnum | null;
+        reducedRate?: number | null;
+        reducedTitle?: string | null;
+        reducedPriceDescription?: string | null;
+        childPriceDescription?: string | null;
+    } | null;
+};
+export type CompositionPriceSource = CompositionPricingConfig & {
+    composition?: OrderComposition | null;
+};
+/**
+ * Базовая категория тарифа: полная доля групповой цены. Ровно одна на тариф —
+ * именно она задаёт «цену за человека», от которой считаются остальные.
+ */
+export declare const baseCategory: (categories: TariffCategory[]) => TariffCategory | undefined;
+/**
+ * Категории тарифа, собранные из легаси-полей. Нужны, пока не все тарифы
+ * прошли бэкфилл и пока старые клиенты присылают тариф без `categories`.
+ *
+ * Соответствие точное, поэтому цена не меняется: льготная ставка — это
+ * категория, занимающая место в составе, а детская — надбавка сверх группы.
+ */
+export declare const categoriesFromLegacy: (config: CompositionPricingConfig) => TariffCategory[];
+/**
+ * Категории, по которым считать цену: собственные, если тариф уже переведён,
+ * иначе собранные из легаси-полей. Без базовой категории список бессмысленен
+ * (не от чего считать доли) — такой тоже уходит в легаси-ветку.
+ */
+export declare const resolveCategories: (config: CompositionPricingConfig) => TariffCategory[];
+/** Нормализованный состав: целые неотрицательные числа, лишние ключи выброшены. */
+export declare const normalizeComposition: (composition: OrderComposition | null | undefined, categories: TariffCategory[]) => OrderComposition;
+/** Гостей всего: и те, что занимают место в сетке, и надбавочные. */
+export declare const getTotalHeads: (composition: OrderComposition | null | undefined, categories: TariffCategory[]) => number;
+/** Гостей, определяющих уровень сетки `price[N]`. */
+export declare const getPricingHeads: (composition: OrderComposition | null | undefined, categories: TariffCategory[]) => number;
+/** Групповая цена уровня. 0 — состав недоступен для брони. */
+export declare const getLevelAmount: (price: Record<string, number> | null | undefined, heads: number) => number;
+/**
+ * Доля одного гостя в групповой цене. Не округляем: остаток от неровного
+ * деления (108 / 3) уходит в скидку места, а групповой итог остаётся ровно
+ * тем, что стоит в прайсе.
+ */
+export declare const getPerPersonAmount: (price: Record<string, number> | null | undefined, heads: number) => number;
+/**
+ * Скидка одного гостя категории от базовой доли.
+ *
+ * Считаем именно скидку, а не цену гостя: групповой итог тогда остаётся
+ * суммой из прайса, а неровное деление не размазывается копейками по головам.
+ */
+export declare const getCategorySeatDiscount: (category: TariffCategory, perPerson: number) => number;
+/** Цена одного гостя категории при текущем составе. */
+export declare const getCategorySeatPrice: (category: TariffCategory, perPerson: number) => number;
+/**
+ * Цена игры за состав.
+ *
+ * Сумма = цена уровня по головам, занимающим место, минус скидки этих голов,
+ * плюс надбавочные категории, и всё это не ниже минимальной стоимости игры.
+ */
+export declare const getCompositionPrice: (source: CompositionPriceSource) => number;
+/**
+ * Сколько гостей категории ещё снижают цену, не упираясь в пол выручки.
+ * Это не лимит выбора — отметить можно больше, цена просто перестанет падать.
+ */
+export declare const getMaxDiscountedSeats: (source: CompositionPriceSource, categoryKey: string) => number;
+/**
+ * Состав по категориям из полей старого формата.
+ *
+ * `reducedPlayers` — это часть `players`, поэтому базовой категории достаётся
+ * остаток. Обратное преобразование — `legacyCountsFromComposition`.
+ */
+export declare const compositionFromLegacy: (legacyCounts: {
+    players?: number | null;
+    children?: number | null;
+    reducedPlayers?: number | null;
+}, categories: TariffCategory[]) => OrderComposition;
+/**
+ * Легаси-поля тарифа, восстановленные из категорий. Обратная операция к
+ * `categoriesFromLegacy`: венью правит тариф уже категориями, а мобильное
+ * приложение и не обновлённые интеграции продолжают читать `price.child` и
+ * `reduced*` — без этой проекции они бы застыли на значениях до перехода.
+ *
+ * Схлопывание с потерями и это нормально: легаси-формат умеет ровно одну
+ * льготную категорию и ровно одну надбавочную. Берём первые — цена там, где
+ * есть `categories`, всё равно считается по ним.
+ */
+export declare const legacyFromCategories: (categories: TariffCategory[], price?: Record<string, number> | null) => {
+    childPrice: number | null;
+    childPriceDescription: string | null;
+    reducedRateMode: TariffReducedRateModeEnum | null;
+    reducedRate: number;
+    reducedTitle: string | null;
+    reducedPriceDescription: string | null;
+};
+/**
+ * Поля старого формата из состава по категориям. Нужны, пока их читают не
+ * обновлённые клиенты (мобильное приложение) и вся отчётность по броням.
+ *
+ * На тарифе с несколькими льготными категориями `reducedPlayers` схлопывает
+ * их в одно число: восстановить цену из легаси-полей в таком случае нельзя,
+ * источник истины — `composition` и снимок категорий на брони.
+ */
+export declare const legacyCountsFromComposition: (composition: OrderComposition | null | undefined, categories: TariffCategory[]) => {
+    players: number;
+    children: number;
+    reducedPlayers: number;
+};

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);
+    });
+});

package/dist/get-players-price.d.ts

@@ -1,8 +1,13 @@
+import { OrderComposition, TariffCategory } from '@escapenavigator/types/dist/tariff/tariff-category';
 import { ReducedPricingConfig } from './reduced-price';
 /**
- * Источник цены игры. Кроме прайс-карты и состава принимает снимок льготной
- * ставки и минимальной стоимости — у `OrderEntity` эти поля есть, поэтому
- * заказы получают правильную цену без правок на каждом вызове.
+ * Источник цены игры. Кроме прайс-карты и состава принимает снимок условий
+ * тарифа — у `OrderEntity` эти поля есть, поэтому заказы получают правильную
+ * цену без правок на каждом вызове.
+ *
+ * Состав задаётся либо категориями (`composition` + `categories`), либо
+ * полями старого формата. Второе оставлено ради не обновлённых клиентов:
+ * внутри всё равно считает один движок — `composition-price`.
  */
 export type GamePriceSource = ReducedPricingConfig & {
     price: Record<string, number>;
@@ -10,6 +15,13 @@ export type GamePriceSource = ReducedPricingConfig & {
     children: number;
     /** Сколько мест в составе идёт по льготной ставке (школьники и т.п.). */
     reducedPlayers?: number | null;
+    /** Категории участников тарифа (или их снимок на брони). */
+    categories?: TariffCategory[] | null;
+    /** Состав по категориям. Приоритетнее полей старого формата. */
+    composition?: OrderComposition | null;
+    reducedTitle?: string | null;
+    reducedPriceDescription?: string | null;
+    childPriceDescription?: string | null;
 };
 export declare const getPlayersPrice: (order: GamePriceSource) => number;
 /**

package/dist/get-players-price.js

@@ -1,25 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMaxGameDiscount = exports.getPlayersPrice = void 0;
+const composition_price_1 = require("./composition-price");
 const reduced_price_1 = require("./reduced-price");
+/** Приводит источник любого поколения к аргументам движка категорий. */
+const toCompositionSource = (order) => {
+    const config = {
+        price: order.price,
+        categories: order.categories,
+        minGameAmount: order.minGameAmount,
+        legacy: {
+            reducedRateMode: order.reducedRateMode,
+            reducedRate: order.reducedRate,
+            reducedTitle: order.reducedTitle,
+            reducedPriceDescription: order.reducedPriceDescription,
+            childPriceDescription: order.childPriceDescription,
+        },
+    };
+    const categories = (0, composition_price_1.resolveCategories)(config);
+    const hasComposition = !!order.composition && Object.keys(order.composition).length > 0;
+    return {
+        ...config,
+        categories,
+        composition: hasComposition
+            ? order.composition
+            : (0, composition_price_1.compositionFromLegacy)(order, categories),
+    };
+};
 const getPlayersPrice = (order) => {
     if (!order?.price)
         return 0;
-    const groupAmount = Number(order.price[order.players]) || 0;
-    const childAmount = !Number.isNaN(+order.price.child) && order.children
-        ? order.price.child * order.children
-        : 0;
-    // Цены на такой состав нет (или она 0 — «состав недоступен»). Заказ по
-    // нему не считается, и минимальная стоимость игры к нему не применяется:
-    // иначе отключённое число игроков внезапно начало бы стоить пол выручки.
-    if (groupAmount <= 0)
-        return childAmount;
-    // Льготные места вычитаются из групповой цены, а не считаются отдельной
-    // суммой по головам: групповой итог остаётся ровно из прайса, а неровное
-    // деление (108 / 3) не размазывается копейками.
-    const seats = Math.min(Math.max(0, Math.floor(Number(order.reducedPlayers) || 0)), order.players);
-    const reducedDiscount = Math.min(seats * (0, reduced_price_1.getReducedSeatDiscount)(order), groupAmount);
-    return (0, reduced_price_1.applyMinGameAmount)(groupAmount - reducedDiscount + childAmount, order);
+    return (0, composition_price_1.getCompositionPrice)(toCompositionSource(order));
 };
 exports.getPlayersPrice = getPlayersPrice;
 /**

package/dist/get-promocode-discount.d.ts

@@ -1,12 +1,17 @@
 import { PromocodeTypeEnum } from '@escapenavigator/types/dist/promocode/emun/promocode-type.enum';
+import { OrderComposition, TariffCategory } from '@escapenavigator/types/dist/tariff/tariff-category';
 import { ReducedPricingConfig } from './reduced-price';
-export declare const getPromocodeDiscount: ({ slotId, slotDiscount, slotDiscountAmount, total, promocodeType, promocodeDiscount, price, players, children, reducedPlayers, reducedRateMode, reducedRate, minGameAmount, }: ReducedPricingConfig & {
+export declare const getPromocodeDiscount: ({ slotId, slotDiscount, slotDiscountAmount, total, promocodeType, promocodeDiscount, price, players, children, reducedPlayers, composition, categories, reducedRateMode, reducedRate, minGameAmount, }: ReducedPricingConfig & {
     slotId: number;
     children?: number;
     total: number;
     players: number;
     /** Сколько мест идёт по льготной ставке (снимок с заказа). */
     reducedPlayers?: number | null;
+    /** Состав по категориям. Приоритетнее полей выше. */
+    composition?: OrderComposition | null;
+    /** Категории тарифа (или их снимок на брони). */
+    categories?: TariffCategory[] | null;
     /**
      * Легаси-параметр: часть вызовов передаёт сумму, часть — ставку в bps.
      * Используется только процентными типами (вычитание из total).

package/dist/get-promocode-discount.js

@@ -4,13 +4,15 @@ exports.getPromocodeDiscount = void 0;
 const promocode_type_enum_1 = require("@escapenavigator/types/dist/promocode/emun/promocode-type.enum");
 const get_players_price_1 = require("./get-players-price");
 const reduced_price_1 = require("./reduced-price");
-const getPromocodeDiscount = ({ slotId, slotDiscount, slotDiscountAmount = 0, total, promocodeType, promocodeDiscount, price, players, children = 0, reducedPlayers = 0, reducedRateMode = null, reducedRate = 0, minGameAmount = 0, }) => {
+const getPromocodeDiscount = ({ slotId, slotDiscount, slotDiscountAmount = 0, total, promocodeType, promocodeDiscount, price, players, children = 0, reducedPlayers = 0, composition, categories, reducedRateMode = null, reducedRate = 0, minGameAmount = 0, }) => {
     const orderTotal = slotId ? total - slotDiscount : total;
     const game = {
         price,
         players,
         children,
         reducedPlayers,
+        composition,
+        categories,
         reducedRateMode,
         reducedRate,
         minGameAmount,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@escapenavigator/utils",
-  "version": "2.0.49",
+  "version": "2.0.50",
   "publishConfig": {
     "access": "public"
   },
@@ -14,7 +14,7 @@
     "test": "jest"
   },
   "dependencies": {
-    "@escapenavigator/types": "^2.0.47",
+    "@escapenavigator/types": "^2.0.48",
     "axios": "^0.21.4",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.13.2",
@@ -29,5 +29,5 @@
     "ts-jest": "^29.1.1",
     "typescript": "^5.6"
   },
-  "gitHead": "9eaab88a1509930c7715945ce519eaeba879f550"
+  "gitHead": "480174116c4a107d2db7e0a4ae92fd0b4e0c63e5"
 }