@escapenavigator/utils 1.10.107 → 1.10.109

package/dist/promocode-error-codes.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromocodeErrorCode = void 0;
+exports.formatPromocodeErrorFallback = formatPromocodeErrorFallback;
+var PromocodeErrorCode;
+(function (PromocodeErrorCode) {
+    PromocodeErrorCode["NOT_AVAILABLE_FOR_CERTIFICATES"] = "NOT_AVAILABLE_FOR_CERTIFICATES";
+    PromocodeErrorCode["NOT_AVAILABLE_FOR_BOOKINGS"] = "NOT_AVAILABLE_FOR_BOOKINGS";
+    PromocodeErrorCode["ALREADY_APPLIED"] = "ALREADY_APPLIED";
+    PromocodeErrorCode["INSIDE_ONLY"] = "INSIDE_ONLY";
+    PromocodeErrorCode["MAX_APPLYINGS_REACHED"] = "MAX_APPLYINGS_REACHED";
+    PromocodeErrorCode["SINGLE_USE"] = "SINGLE_USE";
+    PromocodeErrorCode["NOT_COMBINABLE_WITH_OTHER_DISCOUNTS"] = "NOT_COMBINABLE_WITH_OTHER_DISCOUNTS";
+    PromocodeErrorCode["NOT_COMBINABLE_WITH_CERTIFICATES"] = "NOT_COMBINABLE_WITH_CERTIFICATES";
+    PromocodeErrorCode["NOT_VALID_YET"] = "NOT_VALID_YET";
+    PromocodeErrorCode["EXPIRED"] = "EXPIRED";
+    PromocodeErrorCode["NOT_FOR_ORDER_DATE_FROM"] = "NOT_FOR_ORDER_DATE_FROM";
+    PromocodeErrorCode["NOT_FOR_ORDER_DATE_TO"] = "NOT_FOR_ORDER_DATE_TO";
+    PromocodeErrorCode["QUESTROOM_NOT_ALLOWED"] = "QUESTROOM_NOT_ALLOWED";
+    PromocodeErrorCode["NOT_AVAILABLE_AT_THIS_TIME_FROM"] = "NOT_AVAILABLE_AT_THIS_TIME_FROM";
+    PromocodeErrorCode["NOT_AVAILABLE_AT_THIS_TIME_TO"] = "NOT_AVAILABLE_AT_THIS_TIME_TO";
+    PromocodeErrorCode["NOT_AVAILABLE_THIS_DAY"] = "NOT_AVAILABLE_THIS_DAY";
+    PromocodeErrorCode["MIN_PLAYERS"] = "MIN_PLAYERS";
+    PromocodeErrorCode["MAX_PLAYERS"] = "MAX_PLAYERS";
+})(PromocodeErrorCode || (exports.PromocodeErrorCode = PromocodeErrorCode = {}));
+const FALLBACK_TEXT = {
+    [PromocodeErrorCode.NOT_AVAILABLE_FOR_CERTIFICATES]: "The promocode can't be applied for certificates.",
+    [PromocodeErrorCode.NOT_AVAILABLE_FOR_BOOKINGS]: "The promocode can't be applied for bookings.",
+    [PromocodeErrorCode.ALREADY_APPLIED]: 'Promocode already applied.',
+    [PromocodeErrorCode.INSIDE_ONLY]: 'The promocode can be applied by phone.',
+    [PromocodeErrorCode.MAX_APPLYINGS_REACHED]: 'The maximum number of promocode applications has been reached.',
+    [PromocodeErrorCode.SINGLE_USE]: 'The promocode can only be used once.',
+    [PromocodeErrorCode.NOT_COMBINABLE_WITH_OTHER_DISCOUNTS]: 'The promocode cannot be used with other promocodes or discounts.',
+    [PromocodeErrorCode.NOT_COMBINABLE_WITH_CERTIFICATES]: 'The promocode cannot be used with other certificates.',
+    [PromocodeErrorCode.NOT_VALID_YET]: 'The promocode is not valid yet.',
+    [PromocodeErrorCode.EXPIRED]: 'The promocode has expired.',
+    [PromocodeErrorCode.NOT_FOR_ORDER_DATE_FROM]: 'The promocode is not valid for the selected game date.',
+    [PromocodeErrorCode.NOT_FOR_ORDER_DATE_TO]: 'The promocode is not valid for the selected game date.',
+    [PromocodeErrorCode.QUESTROOM_NOT_ALLOWED]: 'The promocode is not valid for the selected escape room.',
+    [PromocodeErrorCode.NOT_AVAILABLE_AT_THIS_TIME_FROM]: 'The promocode is not available at this time.',
+    [PromocodeErrorCode.NOT_AVAILABLE_AT_THIS_TIME_TO]: 'The promocode is not available at this time.',
+    [PromocodeErrorCode.NOT_AVAILABLE_THIS_DAY]: 'The promocode is not valid for the selected day.',
+    [PromocodeErrorCode.MIN_PLAYERS]: 'Not enough players for the promocode.',
+    [PromocodeErrorCode.MAX_PLAYERS]: 'Too many players for the promocode.',
+};
+/**
+ * Английский fallback для отображения кода ошибки промокода вне i18n-контекста.
+ * Для пользовательского UI нужно использовать i18n-ключи вида
+ * `errors.promocode.<CODE>` с подстановкой `payload`. Эта функция — последний
+ * рубеж, чтобы при ошибке всегда было что показать.
+ */
+function formatPromocodeErrorFallback(error) {
+    const text = FALLBACK_TEXT[error.code];
+    if ('payload' in error && error.payload) {
+        const parts = Object.entries(error.payload)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join(', ');
+        return `${text} (${parts})`;
+    }
+    return text;
+}

package/dist/promocode-nominal-rules.d.ts

@@ -0,0 +1,29 @@
+import { PromocodeNominalRule } from '@escapenavigator/types/dist/promocode/promocode-nominal-rule';
+type NominalLike = {
+    id: number;
+    discount?: number;
+};
+type PromocodeLike = {
+    availableForCertificates?: boolean;
+    certificateNominalRules?: PromocodeNominalRule[];
+};
+/**
+ * Поиск правила промокода для конкретного номинала. Возвращает запись из
+ * `certificateNominalRules` или `null`, если правила нет.
+ */
+export declare function findNominalRule(promocode: PromocodeLike | null | undefined, nominalId: number): PromocodeNominalRule | null;
+/**
+ * Применим ли промокод к данному номиналу: scope охватывает сертификаты и есть
+ * явное правило для `nominal.id`. Если правил нет — промокод к номиналу не
+ * применяется (магазин показывает базовую скидку номинала).
+ */
+export declare function isPromocodeApplicableToNominal(promocode: PromocodeLike | null | undefined, nominal: NominalLike): boolean;
+/**
+ * Эффективная скидка номинала с учётом промокода (если он применим).
+ * Возвращает значение в минимальных единицах валюты.
+ *
+ * - Промокод применим к номиналу → скидка из правила.
+ * - Иначе — базовый `nominal.discount` (или 0).
+ */
+export declare function resolveEffectiveNominalDiscount(promocode: PromocodeLike | null | undefined, nominal: NominalLike): number;
+export {};

package/dist/promocode-nominal-rules.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNominalRule = findNominalRule;
+exports.isPromocodeApplicableToNominal = isPromocodeApplicableToNominal;
+exports.resolveEffectiveNominalDiscount = resolveEffectiveNominalDiscount;
+/**
+ * Поиск правила промокода для конкретного номинала. Возвращает запись из
+ * `certificateNominalRules` или `null`, если правила нет.
+ */
+function findNominalRule(promocode, nominalId) {
+    if (!promocode?.certificateNominalRules?.length)
+        return null;
+    return promocode.certificateNominalRules.find((r) => r.nominalId === nominalId) ?? null;
+}
+/**
+ * Применим ли промокод к данному номиналу: scope охватывает сертификаты и есть
+ * явное правило для `nominal.id`. Если правил нет — промокод к номиналу не
+ * применяется (магазин показывает базовую скидку номинала).
+ */
+function isPromocodeApplicableToNominal(promocode, nominal) {
+    if (!promocode?.availableForCertificates)
+        return false;
+    return findNominalRule(promocode, nominal.id) !== null;
+}
+/**
+ * Эффективная скидка номинала с учётом промокода (если он применим).
+ * Возвращает значение в минимальных единицах валюты.
+ *
+ * - Промокод применим к номиналу → скидка из правила.
+ * - Иначе — базовый `nominal.discount` (или 0).
+ */
+function resolveEffectiveNominalDiscount(promocode, nominal) {
+    const rule = isPromocodeApplicableToNominal(promocode, nominal)
+        ? findNominalRule(promocode, nominal.id)
+        : null;
+    if (rule)
+        return Math.max(0, rule.discount || 0);
+    return Math.max(0, nominal.discount || 0);
+}

package/dist/promocode-nominal-rules.spec.d.ts

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

package/dist/promocode-nominal-rules.spec.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promocode_nominal_rules_1 = require("./promocode-nominal-rules");
+const baseNominal = { id: 10, discount: 500 };
+const promocodeWithRule = {
+    availableForCertificates: true,
+    certificateNominalRules: [
+        { nominalId: 10, discount: 1500 },
+        { nominalId: 20, discount: 700 },
+    ],
+};
+const promocodeWithoutRule = {
+    availableForCertificates: true,
+    certificateNominalRules: [{ nominalId: 99, discount: 1500 }],
+};
+const promocodeBookingsOnly = {
+    availableForCertificates: false,
+    certificateNominalRules: [{ nominalId: 10, discount: 1500 }],
+};
+describe('findNominalRule', () => {
+    it('returns rule when nominal matches', () => {
+        expect((0, promocode_nominal_rules_1.findNominalRule)(promocodeWithRule, 10)).toEqual({
+            nominalId: 10,
+            discount: 1500,
+        });
+    });
+    it('returns null when nominal not in rules', () => {
+        expect((0, promocode_nominal_rules_1.findNominalRule)(promocodeWithRule, 999)).toBeNull();
+    });
+    it('returns null on empty/missing data', () => {
+        expect((0, promocode_nominal_rules_1.findNominalRule)(null, 10)).toBeNull();
+        expect((0, promocode_nominal_rules_1.findNominalRule)(undefined, 10)).toBeNull();
+        expect((0, promocode_nominal_rules_1.findNominalRule)({}, 10)).toBeNull();
+        expect((0, promocode_nominal_rules_1.findNominalRule)({ certificateNominalRules: [] }, 10)).toBeNull();
+    });
+});
+describe('isPromocodeApplicableToNominal', () => {
+    it('true only when scope=certificates and rule exists', () => {
+        expect((0, promocode_nominal_rules_1.isPromocodeApplicableToNominal)(promocodeWithRule, baseNominal)).toBe(true);
+    });
+    it('false when no rule for nominal', () => {
+        expect((0, promocode_nominal_rules_1.isPromocodeApplicableToNominal)(promocodeWithoutRule, baseNominal)).toBe(false);
+    });
+    it('false when scope excludes certificates', () => {
+        expect((0, promocode_nominal_rules_1.isPromocodeApplicableToNominal)(promocodeBookingsOnly, baseNominal)).toBe(false);
+    });
+    it('false on missing promocode', () => {
+        expect((0, promocode_nominal_rules_1.isPromocodeApplicableToNominal)(null, baseNominal)).toBe(false);
+    });
+});
+describe('resolveEffectiveNominalDiscount', () => {
+    it('returns rule discount when applicable', () => {
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)(promocodeWithRule, baseNominal)).toBe(1500);
+    });
+    it('returns base nominal discount when no rule', () => {
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)(promocodeWithoutRule, baseNominal)).toBe(500);
+    });
+    it('returns base discount when no promocode', () => {
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)(null, baseNominal)).toBe(500);
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)(undefined, baseNominal)).toBe(500);
+    });
+    it('clamps negative rule discount to 0', () => {
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)({
+            availableForCertificates: true,
+            certificateNominalRules: [{ nominalId: 10, discount: -50 }],
+        }, baseNominal)).toBe(0);
+    });
+    it('falls back to base when scope excludes certificates', () => {
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)(promocodeBookingsOnly, baseNominal)).toBe(500);
+    });
+    it('returns 0 for missing nominal.discount', () => {
+        expect((0, promocode_nominal_rules_1.resolveEffectiveNominalDiscount)(null, { id: 10 })).toBe(0);
+    });
+});

package/dist/serialize-slot.d.ts

@@ -8,25 +8,6 @@ type Props = {
 };
 export declare const serializeSlotOrderData: (order: OrderRO & {
     workers: any[];
-}) => SlotRO['orders'][number];
-/**
- * Serializes the internal slot model into the public `SlotRO`.
- *
- * The list response no longer carries `durations` or `variations`. For flex
- * slots top-level fields (status/end/tariff/availability) reflect the minimum
- * duration, which is what the slot service has already pre-computed via
- * `groupSlotsWithDurationsAndVariations`.
- *
- * Consumers that need the full duration/variation set should call the
- * `/openapi/slots/details` endpoint on demand.
- */
+}) => SlotRO["orders"][number];
 export declare const serializeSlot: ({ slot, orders }: Props) => SlotRO;
-/**
- * Legacy serializer that emits the old `variations[]` + `variationKind` shape.
- *
- * Kept only for legacy aggregator endpoints where the public response contract
- * cannot be changed (now-escape, ru aggregators). Prefer `serializeSlot` for
- * everything else.
- */
-export declare const serializeSlotLegacy: ({ slot, orders }: Props) => any;
 export {};

package/dist/serialize-slot.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeSlotLegacy = exports.serializeSlot = exports.serializeSlotOrderData = void 0;
+exports.serializeSlot = exports.serializeSlotOrderData = void 0;
 const defailt_rule_1 = require("@escapenavigator/types/dist/slot-rule/defailt-rule");
-const get_full_name_1 = require("./get-full-name");
 const buildRuleSummary = (rule) => {
-    const { prepayment, prepaymentType, title, minHoursForBooking, minHoursForFreeCanceling, cancelationRule, tax, minHoursForFullFine, cancelationAmount, } = rule || defailt_rule_1.defaultRule;
+    const { prepayment, prepaymentType, title, minHoursForBooking, minHoursForFreeCanceling, cancelationRule, minHoursForFullFine, cancelationAmount, } = rule || defailt_rule_1.defaultRule;
     return {
         prepayment,
-        tax,
         minHoursForFullFine,
         cancelationAmount,
         prepaymentType,
@@ -17,13 +15,6 @@ const buildRuleSummary = (rule) => {
         cancelationRule,
     };
 };
-const computeDurationMinutes = (start, end, fallback) => {
-    if (typeof fallback === 'number')
-        return fallback;
-    if (!start || !end)
-        return 0;
-    return (Math.max(0, new Date(`1970-01-01T${end}`).getTime() - new Date(`1970-01-01T${start}`).getTime()) / 60000);
-};
 const serializeSlotOrderData = (order) => order && {
     id: order.id,
     players: order.players,
@@ -36,22 +27,16 @@ const serializeSlotOrderData = (order) => order && {
     slotDiscount: order.slotDiscount,
     otherParticipantsIds: order.workers?.map(({ userId }) => userId) || [],
     code: order.code,
-    clientName: (0, get_full_name_1.getFullName)(order.client),
     hold: order.hold,
     expiration: order.expiration,
+    groupId: order.groupId,
+    client: {
+        id: order.client.id,
+        name: order.client.name,
+        surname: order.client.surname,
+    },
 };
 exports.serializeSlotOrderData = serializeSlotOrderData;
-/**
- * Serializes the internal slot model into the public `SlotRO`.
- *
- * The list response no longer carries `durations` or `variations`. For flex
- * slots top-level fields (status/end/tariff/availability) reflect the minimum
- * duration, which is what the slot service has already pre-computed via
- * `groupSlotsWithDurationsAndVariations`.
- *
- * Consumers that need the full duration/variation set should call the
- * `/openapi/slots/details` endpoint on demand.
- */
 const serializeSlot = ({ slot, orders = [] }) => ({
     id: slot.id,
     questroomId: slot.questroomId,
@@ -73,58 +58,3 @@ const serializeSlot = ({ slot, orders = [] }) => ({
     orders: orders.map((order) => (0, exports.serializeSlotOrderData)(order)),
 });
 exports.serializeSlot = serializeSlot;
-/**
- * Legacy serializer that emits the old `variations[]` + `variationKind` shape.
- *
- * Kept only for legacy aggregator endpoints where the public response contract
- * cannot be changed (now-escape, ru aggregators). Prefer `serializeSlot` for
- * everything else.
- */
-const serializeSlotLegacy = ({ slot, orders = [] }) => {
-    const baseVariation = slot.variations?.[0] || slot;
-    const normalizedVariations = (slot.variations || [baseVariation]).map((variation) => {
-        const duration = computeDurationMinutes(slot.start, variation.end, variation.duration);
-        return {
-            id: variation.id,
-            tariffId: variation.tariffId,
-            ruleId: variation.ruleId,
-            variationKind: variation.variationKind,
-            end: variation.end,
-            duration,
-            tariff: variation.tariff?.price || variation.tariff || {},
-            status: variation.status,
-            discount: variation.discount || 0,
-            onlyPhone: !!variation.onlyPhone,
-            breakReason: variation.breakReason || null,
-            forceOnlineBooking: !!variation.forceOnlineBooking,
-            availableTeams: variation.availableTeams ?? null,
-            numSeatsAvailable: variation.availablePlayers ?? variation.numSeatsAvailable ?? 0,
-            rule: buildRuleSummary(variation.rule || slot.rule),
-        };
-    });
-    const primaryVariation = normalizedVariations.find((variation) => variation.status === 'free')
-        || normalizedVariations.find((variation) => variation.status === 'call')
-        || normalizedVariations[0];
-    return {
-        id: slot.id,
-        questroomId: slot.questroomId,
-        old: slot.old,
-        date: slot.date,
-        start: slot.start,
-        defaultVariationId: slot.defaultVariationId ?? slot.tariffId,
-        variationIds: slot.variationIds || (slot.tariffId != null ? [slot.tariffId] : []),
-        variations: normalizedVariations,
-        end: slot.end || primaryVariation?.end,
-        tariff: primaryVariation?.tariff,
-        status: primaryVariation?.status,
-        discount: primaryVariation?.discount,
-        onlyPhone: primaryVariation?.onlyPhone,
-        forceOnlineBooking: primaryVariation?.forceOnlineBooking,
-        breakReason: primaryVariation?.breakReason,
-        availableTeams: primaryVariation?.availableTeams,
-        numSeatsAvailable: primaryVariation?.numSeatsAvailable,
-        rule: primaryVariation?.rule,
-        orders: orders.map((order) => (0, exports.serializeSlotOrderData)(order)),
-    };
-};
-exports.serializeSlotLegacy = serializeSlotLegacy;

package/dist/transform-text.js

@@ -20,11 +20,13 @@ const BOOKING_BUTTON_STYLE = `
     mso-padding-alt:0px;
     border-radius:6px;
     text-align: center;
-`.replace(/\n\s*/g, ' ').trim();
+`
+    .replace(/\n\s*/g, ' ')
+    .trim();
 const transformText = (text, obj) => {
     let res = text || '';
     const bookingButtonRegex = /\{\{#manageBooking\}\}([\s\S]*?)\{\{\/manageBooking\}\}/g;
-    res = res.replace(bookingButtonRegex, (match, buttonText) => {
+    res = res.replace(bookingButtonRegex, (_match, buttonText) => {
         const link = obj.bookingManagementLink;
         if (!link)
             return buttonText;
@@ -32,8 +34,8 @@ const transformText = (text, obj) => {
         return `<a style="${BOOKING_BUTTON_STYLE}" target="_blank" href="${link}">${trimmedText}</a>`;
     });
     const ifRegex = /\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g;
-    res = res.replace(ifRegex, (match, conditionKey, innerContent) => {
-        if (obj.hasOwnProperty(conditionKey) && obj[conditionKey]) {
+    res = res.replace(ifRegex, (_match, conditionKey, innerContent) => {
+        if (Object.hasOwn(obj, conditionKey) && obj[conditionKey]) {
             return innerContent;
         }
         return '';

package/dist/tz-date.d.ts

@@ -12,6 +12,6 @@ type ToZoned = {
     format?: string;
     showTZ?: boolean;
 };
-export declare const convertDateToZonedDate: ({ date, timeZone, time, offset, }: ToUTC) => Date;
+export declare const convertDateToZonedDate: ({ date, timeZone, time, offset }: ToUTC) => Date;
 export declare const convertUTCDateToZonedDate: ({ date, timeZone, offset, format, showTZ, }: ToZoned) => string;
 export {};

package/dist/tz-date.js

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertUTCDateToZonedDate = exports.convertDateToZonedDate = void 0;
-const date_fns_1 = require("date-fns");
-const date_fns_tz_1 = require("date-fns-tz");
-const convertDateToZonedDate = ({ date, timeZone, time, offset, }) => {
+const date_1 = require("./date");
+const convertDateToZonedDate = ({ date, timeZone, time, offset }) => {
     let d = typeof date === 'string'
-        ? (0, date_fns_1.parse)(time ? `${date} ${time}` : date, time ? 'yyyy-MM-dd HH:mm' : 'yyyy-MM-dd', new Date())
+        ? (0, date_1.parseDate)(time ? `${date} ${time}` : date, time ? 'yyyy-MM-dd HH:mm' : 'yyyy-MM-dd')
         : date;
     if (offset)
-        d = (0, date_fns_1.addHours)(d, offset);
-    return (0, date_fns_tz_1.zonedTimeToUtc)(d, timeZone);
+        d = (0, date_1.addHours)(d, offset);
+    return (0, date_1.zonedTimeToUtc)(d, timeZone);
 };
 exports.convertDateToZonedDate = convertDateToZonedDate;
 const convertUTCDateToZonedDate = ({ date, timeZone, offset = 0, format = 'dd.MM.yyyy, HH:mm', showTZ = false, }) => {
     if (!date)
         return '';
-    const d = (0, date_fns_tz_1.utcToZonedTime)(date, timeZone);
-    const dt = (0, date_fns_1.addHours)(d, offset);
-    const res = (0, date_fns_1.format)(dt, format);
+    const d = (0, date_1.utcToZonedTime)(date, timeZone);
+    const dt = (0, date_1.addHours)(d, offset);
+    const res = (0, date_1.formatDate)(dt, format);
     return showTZ ? `${res} (${timeZone})` : res;
 };
 exports.convertUTCDateToZonedDate = convertUTCDateToZonedDate;

package/dist/utm-touchpoints.d.ts

@@ -0,0 +1,63 @@
+export type UtmFields = {
+    utmSource?: string | null;
+    utmMedium?: string | null;
+    utmCampaign?: string | null;
+    utmContent?: string | null;
+    utmTerm?: string | null;
+    /**
+     * Внутренний (escapenavigator) ID кампании. В отличие от `utmCampaign`,
+     * не редактируется юзером — стабильный FK на
+     * `profile-marketing-email-campaign.id`. Используется для точной
+     * атрибуции (без LIKE по slug-у) в `computeAttribution`.
+     */
+    enCampaignId?: number | null;
+    /**
+     * ID конкретной ссылки внутри письма (например, `cta_primary` или
+     * `section_${i}`). Нужен, чтобы считать CTR разных ссылок в одном
+     * письме. Last-click: при повторном клике перезаписывается в widget
+     * session storage.
+     */
+    enLinkId?: string | null;
+};
+/**
+ * Нормализация одного UTM-поля для индекса/поиска: trim + lowercase.
+ * Пустые/undefined значения превращаются в пустую строку, чтобы UNIQUE индекс
+ * `(clientId, *Norm)` корректно покрывал «нет такого параметра».
+ *
+ * NOTE: Postgres-`UNIQUE` рассматривает `NULL` как "не равно `NULL`", поэтому
+ * без явной пустой строки две записи с `utmCampaignNorm = NULL` считаются
+ * разными и UNIQUE их не отсечёт. Здесь — '' гарантирует дедуп.
+ */
+export declare function normalizeUtmField(value: string | null | undefined): string;
+/**
+ * Нормализует `enCampaignId`: из любого `number | string | null | undefined`
+ * получаем либо положительный integer, либо `null`. Нужно потому что значение
+ * может прилететь из URL (строка), из БД (number) или из widget-а (Number).
+ */
+export declare function normalizeEnCampaignId(value: number | string | null | undefined): number | null;
+/**
+ * Нормализованный объект UTM с гарантированными ключами `*Norm`.
+ *
+ * `enLinkIdNorm` — пустая строка, если `enLinkId` отсутствует, по той же
+ * причине что и остальные `*Norm` (см. комментарий в `normalizeUtmField`).
+ * `enCampaignId` остаётся `number | null`; для UNIQUE-индекса мы кладём
+ * `0` вместо `null` на стороне сервиса (см. ClientUtmTouchpointService).
+ */
+export type NormalizedUtm = {
+    utmSourceNorm: string;
+    utmMediumNorm: string;
+    utmCampaignNorm: string;
+    utmContentNorm: string;
+    utmTermNorm: string;
+    enLinkIdNorm: string;
+    enCampaignId: number | null;
+};
+export declare function normalizeUtm(utm: UtmFields | null | undefined): NormalizedUtm;
+/**
+ * `true`, если все поля атрибуции пустые после нормализации — такой
+ * touchpoint сохранять не нужно (данных нет). С появлением `en_*` «пусто»
+ * = пусты И 5 UTM-полей, И `enCampaignId/enLinkId`, иначе пропустим
+ * легитимные касания вида «только en_campaign_id, без UTM» (например,
+ * если юзер очистит UTM в кампании, но `en_*` мы добавим всегда).
+ */
+export declare function isEmptyUtm(utm: UtmFields | null | undefined): boolean;

package/dist/utm-touchpoints.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeUtmField = normalizeUtmField;
+exports.normalizeEnCampaignId = normalizeEnCampaignId;
+exports.normalizeUtm = normalizeUtm;
+exports.isEmptyUtm = isEmptyUtm;
+const UTM_STRING_KEYS = [
+    'utmSource',
+    'utmMedium',
+    'utmCampaign',
+    'utmContent',
+    'utmTerm',
+];
+/**
+ * Нормализация одного UTM-поля для индекса/поиска: trim + lowercase.
+ * Пустые/undefined значения превращаются в пустую строку, чтобы UNIQUE индекс
+ * `(clientId, *Norm)` корректно покрывал «нет такого параметра».
+ *
+ * NOTE: Postgres-`UNIQUE` рассматривает `NULL` как "не равно `NULL`", поэтому
+ * без явной пустой строки две записи с `utmCampaignNorm = NULL` считаются
+ * разными и UNIQUE их не отсечёт. Здесь — '' гарантирует дедуп.
+ */
+function normalizeUtmField(value) {
+    if (value === undefined || value === null)
+        return '';
+    return String(value).trim().toLowerCase();
+}
+/**
+ * Нормализует `enCampaignId`: из любого `number | string | null | undefined`
+ * получаем либо положительный integer, либо `null`. Нужно потому что значение
+ * может прилететь из URL (строка), из БД (number) или из widget-а (Number).
+ */
+function normalizeEnCampaignId(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n) || n <= 0)
+        return null;
+    return Math.trunc(n);
+}
+function normalizeUtm(utm) {
+    return {
+        utmSourceNorm: normalizeUtmField(utm?.utmSource),
+        utmMediumNorm: normalizeUtmField(utm?.utmMedium),
+        utmCampaignNorm: normalizeUtmField(utm?.utmCampaign),
+        utmContentNorm: normalizeUtmField(utm?.utmContent),
+        utmTermNorm: normalizeUtmField(utm?.utmTerm),
+        enLinkIdNorm: normalizeUtmField(utm?.enLinkId),
+        enCampaignId: normalizeEnCampaignId(utm?.enCampaignId),
+    };
+}
+/**
+ * `true`, если все поля атрибуции пустые после нормализации — такой
+ * touchpoint сохранять не нужно (данных нет). С появлением `en_*` «пусто»
+ * = пусты И 5 UTM-полей, И `enCampaignId/enLinkId`, иначе пропустим
+ * легитимные касания вида «только en_campaign_id, без UTM» (например,
+ * если юзер очистит UTM в кампании, но `en_*` мы добавим всегда).
+ */
+function isEmptyUtm(utm) {
+    if (!utm)
+        return true;
+    const allUtmEmpty = UTM_STRING_KEYS.every((key) => normalizeUtmField(utm[key]) === '');
+    const enLinkEmpty = normalizeUtmField(utm.enLinkId) === '';
+    const enCampaignEmpty = normalizeEnCampaignId(utm.enCampaignId) === null;
+    return allUtmEmpty && enLinkEmpty && enCampaignEmpty;
+}

package/dist/utm-touchpoints.spec.d.ts

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

package/dist/utm-touchpoints.spec.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utm_touchpoints_1 = require("./utm-touchpoints");
+describe('normalizeUtmField', () => {
+    it('lowercases and trims', () => {
+        expect((0, utm_touchpoints_1.normalizeUtmField)('  Summer ')).toBe('summer');
+        expect((0, utm_touchpoints_1.normalizeUtmField)('FACEBOOK')).toBe('facebook');
+    });
+    it('returns empty string for null/undefined', () => {
+        expect((0, utm_touchpoints_1.normalizeUtmField)(null)).toBe('');
+        expect((0, utm_touchpoints_1.normalizeUtmField)(undefined)).toBe('');
+    });
+    it('returns empty string for whitespace-only', () => {
+        expect((0, utm_touchpoints_1.normalizeUtmField)('   ')).toBe('');
+    });
+    it('preserves non-trimmed inner content', () => {
+        expect((0, utm_touchpoints_1.normalizeUtmField)('  black friday 2024  ')).toBe('black friday 2024');
+    });
+});
+describe('normalizeEnCampaignId', () => {
+    it('keeps positive integers', () => {
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(42)).toBe(42);
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)('42')).toBe(42);
+    });
+    it('returns null for non-positive / non-finite / empty', () => {
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(null)).toBeNull();
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(undefined)).toBeNull();
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(0)).toBeNull();
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(-1)).toBeNull();
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)('')).toBeNull();
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)('abc')).toBeNull();
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(Number.NaN)).toBeNull();
+    });
+    it('truncates fractional part', () => {
+        expect((0, utm_touchpoints_1.normalizeEnCampaignId)(3.7)).toBe(3);
+    });
+});
+describe('normalizeUtm', () => {
+    it('produces 5 *Norm fields plus enLinkIdNorm and enCampaignId', () => {
+        const out = (0, utm_touchpoints_1.normalizeUtm)({
+            utmSource: ' Google ',
+            utmMedium: 'CPC',
+            utmCampaign: undefined,
+            utmContent: null,
+            utmTerm: 'BUY',
+            enCampaignId: 17,
+            enLinkId: ' Cta_Primary ',
+        });
+        expect(out).toEqual({
+            utmSourceNorm: 'google',
+            utmMediumNorm: 'cpc',
+            utmCampaignNorm: '',
+            utmContentNorm: '',
+            utmTermNorm: 'buy',
+            enLinkIdNorm: 'cta_primary',
+            enCampaignId: 17,
+        });
+    });
+    it('handles empty input', () => {
+        expect((0, utm_touchpoints_1.normalizeUtm)({})).toEqual({
+            utmSourceNorm: '',
+            utmMediumNorm: '',
+            utmCampaignNorm: '',
+            utmContentNorm: '',
+            utmTermNorm: '',
+            enLinkIdNorm: '',
+            enCampaignId: null,
+        });
+        expect((0, utm_touchpoints_1.normalizeUtm)(null)).toEqual({
+            utmSourceNorm: '',
+            utmMediumNorm: '',
+            utmCampaignNorm: '',
+            utmContentNorm: '',
+            utmTermNorm: '',
+            enLinkIdNorm: '',
+            enCampaignId: null,
+        });
+    });
+});
+describe('isEmptyUtm', () => {
+    it('true for null/undefined/empty', () => {
+        expect((0, utm_touchpoints_1.isEmptyUtm)(null)).toBe(true);
+        expect((0, utm_touchpoints_1.isEmptyUtm)(undefined)).toBe(true);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({})).toBe(true);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ utmSource: '   ' })).toBe(true);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ utmCampaign: '' })).toBe(true);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ enCampaignId: 0, enLinkId: '   ' })).toBe(true);
+    });
+    it('false if any non-blank field present', () => {
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ utmSource: 'google' })).toBe(false);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ utmCampaign: 'X', utmTerm: '' })).toBe(false);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ enCampaignId: 5 })).toBe(false);
+        expect((0, utm_touchpoints_1.isEmptyUtm)({ enLinkId: 'cta_primary' })).toBe(false);
+    });
+});

package/dist/validate-by-dto.d.ts

@@ -1 +1 @@
-export declare function validateByDto(t: any): <T>(data: T) => void | Record<string, unknown>;
+export declare function validateByDto(t: any): <T>(data: T) => undefined | Record<string, unknown>;