includio-cms 0.36.8 → 0.37.0

package/dist/booking/participant-pricing.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Per-participant booking pricing — pure, deterministic, module-agnostic.
+ *
+ * Unlike the per-line {@link price} engine, this prices each *participant ×
+ * trip* unit, so age-based pricing and volume discounts compose correctly:
+ *
+ *   line base   = round(adultPrice * ageBandPct / 100)
+ *   package     = participant's cheapest trip * ladder%   (full-price only)
+ *   early-bird  = participant's gross * earlyBird%         (full-price only)
+ *
+ * INVARIANT: volume discounts (package + early-bird) apply ONLY to full-price
+ * participants (age band pct === 100). Any participant with an age discount is
+ * excluded — "a child already on −30% does not also stack the bundle".
+ *
+ * Amounts are in **minor units** (grosze). No clock access: `now` and `anchor`
+ * (the arrival date) are injected by the caller.
+ */
+import type { Perk } from './pricing.js';
+/** A global age band: participants aged [minAge, maxAge] pay `pct`% of adult price. */
+export interface AgeBand {
+    label?: string;
+    /** Inclusive lower bound (whole years). */
+    minAge: number;
+    /** Inclusive upper bound (whole years); `null` ⇒ no upper bound. */
+    maxAge: number | null;
+    /** Percent of the adult price, 0–100. */
+    pct: number;
+}
+/** Resolve the age-band percent for an age; 100 when null/unmatched (full price). */
+export declare function bandPctFor(age: number | null, bands: AgeBand[]): number;
+/** One ladder tier: from `minTrips` trips, the cheapest trip gets `percent`% off. */
+export interface LadderTier {
+    minTrips: number;
+    percent: number;
+    perk?: string;
+}
+/** Highest ladder tier whose `minTrips` ≤ tripCount; null when none qualifies. */
+export declare function ladderTierFor(tripCount: number, ladder: LadderTier[]): LadderTier | null;
+/** Early-bird: `percent`% off a full-price participant's gross when booked early. */
+export interface EarlyBird {
+    daysBefore: number;
+    percent: number;
+}
+/** Serializable per-participant pricing config (sourced from client globalSettings). */
+export interface ParticipantPricingConfig {
+    ageBands: AgeBand[];
+    ladder: LadderTier[];
+    earlyBird?: EarlyBird | null;
+}
+/** A trip available in the booking, with its full (adult) price (minor units). */
+export interface PricedTrip {
+    ref: string;
+    adultPrice: number;
+}
+/** A participant and the trips they take. */
+export interface PricingParticipant {
+    id: string;
+    /** ISO date of birth; `null`/invalid ⇒ treated as a full-price adult. */
+    dob: string | null;
+    tripRefs: string[];
+}
+export interface ParticipantLine {
+    tripRef: string;
+    /** Age-adjusted base for this participant on this trip (minor units). */
+    base: number;
+}
+export interface ParticipantBreakdown {
+    participantId: string;
+    /** Resolved age-band percent (100 when no band matches / no dob). */
+    ageBandPct: number;
+    /** True ⇔ ageBandPct === 100 (eligible for volume discounts). */
+    fullPrice: boolean;
+    lines: ParticipantLine[];
+    /** Sum of line bases. */
+    gross: number;
+    /** Package (ladder) discount, minor units (0 when ineligible). */
+    packageDiscount: number;
+    /** Trip ref the package discount targets, or null. */
+    packageTargetRef: string | null;
+    /** Early-bird discount, minor units (0 when ineligible). */
+    earlyBirdDiscount: number;
+    perks: string[];
+    /** gross − packageDiscount − earlyBirdDiscount. */
+    net: number;
+}
+export interface ParticipantPriceResult {
+    gross: number;
+    discountTotal: number;
+    net: number;
+    participants: ParticipantBreakdown[];
+    perks: Perk[];
+}
+export declare function priceByParticipant(participants: PricingParticipant[], trips: PricedTrip[], anchor: Date | null, now: Date, config: ParticipantPricingConfig): ParticipantPriceResult;

package/dist/booking/participant-pricing.js

@@ -0,0 +1,91 @@
+import { daysUntil } from './pricing.js';
+import { ageAt } from './participant-fields/age.js';
+/** Resolve the age-band percent for an age; 100 when null/unmatched (full price). */
+export function bandPctFor(age, bands) {
+    if (age === null)
+        return 100;
+    for (const b of bands) {
+        const lo = age >= b.minAge;
+        const hi = b.maxAge === null || age <= b.maxAge;
+        if (lo && hi)
+            return b.pct;
+    }
+    return 100;
+}
+/** Highest ladder tier whose `minTrips` ≤ tripCount; null when none qualifies. */
+export function ladderTierFor(tripCount, ladder) {
+    let best = null;
+    for (const t of ladder) {
+        if (tripCount >= t.minTrips && (!best || t.minTrips > best.minTrips))
+            best = t;
+    }
+    return best;
+}
+export function priceByParticipant(participants, trips, anchor, now, config) {
+    const priceOf = new Map(trips.map((t) => [t.ref, t.adultPrice]));
+    const daysBefore = anchor ? daysUntil(anchor, now) : null;
+    const breakdowns = participants.map((p) => {
+        const age = p.dob && anchor ? ageAt(p.dob, anchor) : null;
+        const pct = bandPctFor(age, config.ageBands);
+        const fullPrice = pct === 100;
+        const lines = p.tripRefs.map((ref) => ({
+            tripRef: ref,
+            base: Math.round(((priceOf.get(ref) ?? 0) * pct) / 100)
+        }));
+        const gross = lines.reduce((s, l) => s + l.base, 0);
+        let packageDiscount = 0;
+        let packageTargetRef = null;
+        const perks = [];
+        if (fullPrice) {
+            const tier = ladderTierFor(p.tripRefs.length, config.ladder);
+            if (tier) {
+                const cheapest = lines.reduce((min, l) => (!min || l.base < min.base ? l : min), null);
+                if (cheapest) {
+                    packageDiscount = Math.round((cheapest.base * tier.percent) / 100);
+                    packageTargetRef = cheapest.tripRef;
+                }
+                if (tier.perk)
+                    perks.push(tier.perk);
+            }
+        }
+        let earlyBirdDiscount = 0;
+        if (fullPrice &&
+            config.earlyBird &&
+            daysBefore !== null &&
+            daysBefore >= config.earlyBird.daysBefore) {
+            earlyBirdDiscount = Math.round((gross * config.earlyBird.percent) / 100);
+        }
+        const net = Math.max(0, gross - packageDiscount - earlyBirdDiscount);
+        return {
+            participantId: p.id,
+            ageBandPct: pct,
+            fullPrice,
+            lines,
+            gross,
+            packageDiscount,
+            packageTargetRef,
+            earlyBirdDiscount,
+            perks,
+            net
+        };
+    });
+    const gross = breakdowns.reduce((s, b) => s + b.gross, 0);
+    const discountTotal = breakdowns.reduce((s, b) => s + b.packageDiscount + b.earlyBirdDiscount, 0);
+    const seen = new Set();
+    const perks = [];
+    for (const b of breakdowns) {
+        for (const label of b.perks) {
+            if (seen.has(label))
+                continue;
+            seen.add(label);
+            perks.push({ label });
+        }
+    }
+    return {
+        gross,
+        discountTotal: Math.min(gross, discountTotal),
+        net: Math.max(0, gross - discountTotal),
+        participants: breakdowns,
+        perks
+    };
+}

package/dist/booking/participants-view.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Pure read adapter: fold person + assignment rows into the flat
+ * "participant per trip line" shape the admin/portal UI was written against
+ * (one row per person×item, with identity + per-trip answers merged into
+ * `data`). Keeps the read DTOs backward-compatible while the storage moved to
+ * the person-centric model. UI modernization (split identity vs per-trip) is a
+ * later plan.
+ */
+/** Person row (subset). `data` holds identity answers (name, dob, …). */
+export interface PersonRecord {
+    id: string;
+    data: Record<string, unknown>;
+}
+/** Assignment (junction) row (subset). `data` holds per-trip answers. */
+export interface AssignmentRecord {
+    id: string;
+    itemId: string;
+    personId: string;
+    data: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/** Flat participant: one per assignment, identity + per-trip `data` merged. */
+export interface FlatParticipant {
+    id: string;
+    itemId: string;
+    personId: string;
+    data: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare function flattenAssignments(persons: PersonRecord[], assignments: AssignmentRecord[]): FlatParticipant[];

package/dist/booking/participants-view.js

@@ -0,0 +1,22 @@
+/**
+ * Pure read adapter: fold person + assignment rows into the flat
+ * "participant per trip line" shape the admin/portal UI was written against
+ * (one row per person×item, with identity + per-trip answers merged into
+ * `data`). Keeps the read DTOs backward-compatible while the storage moved to
+ * the person-centric model. UI modernization (split identity vs per-trip) is a
+ * later plan.
+ */
+export function flattenAssignments(persons, assignments) {
+    const personById = new Map(persons.map((p) => [p.id, p]));
+    return assignments.map((a) => {
+        const person = personById.get(a.personId);
+        return {
+            id: a.id,
+            itemId: a.itemId,
+            personId: a.personId,
+            data: { ...(person?.data ?? {}), ...a.data },
+            createdAt: a.createdAt,
+            updatedAt: a.updatedAt
+        };
+    });
+}

package/dist/booking/payment-context.d.ts

@@ -0,0 +1,19 @@
+import type { PaymentCreateContext } from '../shop/types.js';
+/** Split "Imię Nazwisko" → first/last (first whitespace splits). */
+export declare function splitName(name: string): {
+    firstName?: string;
+    lastName?: string;
+};
+export interface BuildPaymentContextInput {
+    accessToken: string;
+    language: string | null;
+    customer: Record<string, unknown>;
+    portalUrlTemplate: string | null;
+}
+/**
+ * Build the {@link PaymentCreateContext} a booking hands to its payment adapter:
+ * a fully-resolved portal `continueUrl` (template `{token}` → accessToken) plus
+ * buyer identity derived from `customer`. Lets any shop adapter serve booking
+ * without a shop module.
+ */
+export declare function buildPaymentContext(input: BuildPaymentContextInput): PaymentCreateContext;

package/dist/booking/payment-context.js

@@ -0,0 +1,29 @@
+/** Split "Imię Nazwisko" → first/last (first whitespace splits). */
+export function splitName(name) {
+    const trimmed = (name ?? '').trim();
+    if (!trimmed)
+        return {};
+    const firstSpace = trimmed.search(/\s/);
+    if (firstSpace === -1)
+        return { firstName: trimmed };
+    return {
+        firstName: trimmed.slice(0, firstSpace),
+        lastName: trimmed.slice(firstSpace + 1).trim() || undefined
+    };
+}
+/**
+ * Build the {@link PaymentCreateContext} a booking hands to its payment adapter:
+ * a fully-resolved portal `continueUrl` (template `{token}` → accessToken) plus
+ * buyer identity derived from `customer`. Lets any shop adapter serve booking
+ * without a shop module.
+ */
+export function buildPaymentContext(input) {
+    const { accessToken, language, customer, portalUrlTemplate } = input;
+    const { firstName, lastName } = splitName(String(customer.name ?? ''));
+    const phone = String(customer.phone ?? '').trim() || undefined;
+    return {
+        language,
+        continueUrl: portalUrlTemplate ? portalUrlTemplate.replace('{token}', accessToken) : undefined,
+        buyer: { firstName, lastName, phone }
+    };
+}

package/dist/booking/pricing-inputs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure adapter: person + item + assignment rows → {@link priceByParticipant}
+ * inputs. Resolves each person's date of birth from identity `data` via the
+ * role:'birthDate' field; dedupes trips by `tripRef`.
+ */
+import type { FieldDef } from './participant-fields/types.js';
+import type { PricingParticipant, PricedTrip } from './participant-pricing.js';
+/** Person row (subset needed for pricing). */
+export interface PersonRow {
+    id: string;
+    data: Record<string, unknown>;
+}
+/** Trip-line row (subset needed for pricing). `unitPrice` = adult price (minor units). */
+export interface ItemRow {
+    id: string;
+    tripRef: string;
+    unitPrice: number;
+}
+/** Assignment (junction) row. */
+export interface ItemPersonRow {
+    itemId: string;
+    personId: string;
+}
+export interface PricingInputs {
+    participants: PricingParticipant[];
+    trips: PricedTrip[];
+}
+export declare function buildPricingInputs(persons: PersonRow[], items: ItemRow[], assignments: ItemPersonRow[], identityFields: FieldDef[]): PricingInputs;

package/dist/booking/pricing-inputs.js

@@ -0,0 +1,35 @@
+export function buildPricingInputs(persons, items, assignments, identityFields) {
+    const dobKey = identityFields.find((f) => f.role === 'birthDate')?.key ?? null;
+    const tripRefByItem = new Map(items.map((it) => [it.id, it.tripRef]));
+    const tripsByPerson = new Map();
+    for (const a of assignments) {
+        const tripRef = tripRefByItem.get(a.itemId);
+        if (tripRef === undefined)
+            continue;
+        const list = tripsByPerson.get(a.personId);
+        if (list) {
+            if (!list.includes(tripRef))
+                list.push(tripRef);
+        }
+        else {
+            tripsByPerson.set(a.personId, [tripRef]);
+        }
+    }
+    const participants = persons.map((p) => {
+        const dobRaw = dobKey ? p.data[dobKey] : null;
+        return {
+            id: p.id,
+            dob: typeof dobRaw === 'string' ? dobRaw : null,
+            tripRefs: tripsByPerson.get(p.id) ?? []
+        };
+    });
+    const seen = new Set();
+    const trips = [];
+    for (const it of items) {
+        if (seen.has(it.tripRef))
+            continue;
+        seen.add(it.tripRef);
+        trips.push({ ref: it.tripRef, adultPrice: it.unitPrice });
+    }
+    return { participants, trips };
+}

package/dist/booking/pricing.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Booking discount rules engine — a pure, deterministic, module-agnostic
+ * function. No side effects, no clock access (the caller passes `now`).
+ *
+ * A rule is serializable data (`when` conditions → `then` effects). Rules carry
+ * an optional `group`: within a group the single largest-discount rule wins;
+ * across groups discounts sum. Amounts are in **minor units** (grosze).
+ */
+/** A condition; all conditions in a rule's `when` must hold (logical AND). */
+export type Condition = {
+    kind: 'minTripCount';
+    value: number;
+} | {
+    kind: 'minParticipants';
+    value: number;
+} | {
+    kind: 'minDaysBefore';
+    value: number;
+};
+/** An effect applied when a rule wins its group. */
+export type Effect = {
+    kind: 'percentOff';
+    value: number;
+} | {
+    kind: 'amountOff';
+    value: number;
+} | {
+    kind: 'percentOffCheapestLine';
+    value: number;
+} | {
+    kind: 'grantPerk';
+    label: string;
+    code?: string;
+};
+/** A serializable discount rule. */
+export interface DiscountRule {
+    /** Stable id (labels, audit, future UI). */
+    id: string;
+    /** Human label for admin/portal/email; defaults to `id`. */
+    label?: string;
+    /** Exclusivity group; rules in the same group compete (one wins). Omitted ⇒ own singleton group. */
+    group?: string;
+    /** Tiebreak within a group when discount amounts are equal (higher wins). Default 0. */
+    priority?: number;
+    when: Condition[];
+    then: Effect[];
+}
+export interface PricingConfig {
+    rules?: DiscountRule[];
+}
+/** A single priced line that retains trip identity (for cheapest/distinct-count). */
+export interface PricingLine {
+    /** Trip reference — identity for distinct-count and discount targeting. */
+    ref: string;
+    /** Unit price (minor units), per participant. */
+    unitPrice: number;
+    /** Participant count on this line. */
+    quantity: number;
+    /** Departure date — drives early-bird (earliest across lines). */
+    departureDate: Date | null;
+    /** Precomputed line gross (minor units); overrides unitPrice*quantity when set. */
+    subtotal?: number;
+}
+export interface AppliedRule {
+    ruleId: string;
+    /** Human label (rule.label ?? rule.id). */
+    label: string;
+    /** Monetary discount contributed, in minor units. */
+    amount: number;
+    /** Line `ref` this discount targets (set for line-targeted effects only). */
+    targetRef?: string;
+}
+export interface Perk {
+    code?: string;
+    label: string;
+}
+export interface PriceResult {
+    gross: number;
+    discountTotal: number;
+    net: number;
+    appliedRules: AppliedRule[];
+    perks: Perk[];
+}
+/** Whole days from `now` until `departureDate` (negative if departure is past). */
+export declare function daysUntil(departureDate: Date, now: Date): number;
+export declare function price(lines: PricingLine[], now: Date, config: PricingConfig): PriceResult;

package/dist/booking/pricing.js

@@ -0,0 +1,125 @@
+/**
+ * Booking discount rules engine — a pure, deterministic, module-agnostic
+ * function. No side effects, no clock access (the caller passes `now`).
+ *
+ * A rule is serializable data (`when` conditions → `then` effects). Rules carry
+ * an optional `group`: within a group the single largest-discount rule wins;
+ * across groups discounts sum. Amounts are in **minor units** (grosze).
+ */
+const MS_PER_DAY = 86_400_000;
+/** Whole days from `now` until `departureDate` (negative if departure is past). */
+export function daysUntil(departureDate, now) {
+    return Math.floor((departureDate.getTime() - now.getTime()) / MS_PER_DAY);
+}
+function conditionHolds(c, ctx) {
+    switch (c.kind) {
+        case 'minTripCount':
+            return ctx.distinctTrips >= c.value;
+        case 'minParticipants':
+            return ctx.totalQty >= c.value;
+        case 'minDaysBefore':
+            return ctx.daysBefore >= c.value;
+    }
+}
+/** Monetary amount of an effect, clamped to [0, gross]; null for non-monetary effects. */
+function effectMonetary(e, ctx) {
+    switch (e.kind) {
+        case 'percentOff':
+            return { amount: Math.max(0, Math.min(ctx.gross, Math.round((ctx.gross * e.value) / 100))) };
+        case 'amountOff':
+            return { amount: Math.max(0, Math.min(ctx.gross, Math.round(e.value))) };
+        case 'percentOffCheapestLine': {
+            if (!ctx.cheapest)
+                return null;
+            const amt = Math.round((ctx.cheapest.total * e.value) / 100);
+            return { amount: Math.max(0, Math.min(ctx.gross, amt)), targetRef: ctx.cheapest.ref };
+        }
+        case 'grantPerk':
+            return null;
+    }
+}
+/**
+ * Prices a set of lines against discount rules.
+ *
+ * @param lines - Priced lines retaining trip identity (minor units).
+ * @param now - Reference "current" time (injected for determinism).
+ * @param config - Discount rules (values from client config).
+ */
+/** Line gross: explicit subtotal when provided, else unitPrice * quantity. */
+function lineTotal(l) {
+    return l.subtotal ?? l.unitPrice * l.quantity;
+}
+export function price(lines, now, config) {
+    const gross = lines.reduce((s, l) => s + lineTotal(l), 0);
+    const totalQty = lines.reduce((s, l) => s + l.quantity, 0);
+    const distinctTrips = new Set(lines.map((l) => l.ref)).size;
+    const dated = lines.map((l) => l.departureDate).filter((d) => d instanceof Date);
+    const basis = dated.length ? new Date(Math.min(...dated.map((d) => d.getTime()))) : now;
+    const daysBefore = daysUntil(basis, now);
+    let cheapest = null;
+    for (const l of lines) {
+        const total = lineTotal(l);
+        if (!cheapest || total < cheapest.total)
+            cheapest = { ref: l.ref, total };
+    }
+    const ctx = { gross, totalQty, distinctTrips, daysBefore, cheapest };
+    // Eligible rules, preserving declaration order.
+    const eligible = (config.rules ?? [])
+        .map((r, i) => ({ r, i }))
+        .filter(({ r }) => r.when.every((c) => conditionHolds(c, ctx)));
+    // Bucket by exclusivity group (omitted group ⇒ unique singleton).
+    const groups = new Map();
+    for (const e of eligible) {
+        const key = e.r.group ?? `__single__${e.i}`;
+        const bucket = groups.get(key);
+        if (bucket)
+            bucket.push(e);
+        else
+            groups.set(key, [e]);
+    }
+    const appliedRules = [];
+    const perks = [];
+    for (const members of groups.values()) {
+        const evaluated = members.map(({ r, i }) => {
+            const effects = r.then.map((e) => ({ e, m: effectMonetary(e, ctx) }));
+            const monetary = effects.reduce((s, x) => s + (x.m?.amount ?? 0), 0);
+            return { r, i, effects, monetary };
+        });
+        // Winner: largest monetary, tie → higher priority, tie → earlier order.
+        evaluated.sort((a, b) => b.monetary - a.monetary || (b.r.priority ?? 0) - (a.r.priority ?? 0) || a.i - b.i);
+        const winner = evaluated[0];
+        if (!winner)
+            continue;
+        for (const { e, m } of winner.effects) {
+            if (e.kind === 'grantPerk') {
+                perks.push({ code: e.code, label: e.label });
+            }
+            else if (m && m.amount > 0) {
+                const ar = {
+                    ruleId: winner.r.id,
+                    label: winner.r.label ?? winner.r.id,
+                    amount: m.amount
+                };
+                if (m.targetRef)
+                    ar.targetRef = m.targetRef;
+                appliedRules.push(ar);
+            }
+        }
+    }
+    const discountTotal = Math.min(gross, appliedRules.reduce((s, a) => s + a.amount, 0));
+    const seen = new Set();
+    const dedupedPerks = perks.filter((p) => {
+        const k = p.code ?? p.label;
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+    return {
+        gross,
+        discountTotal,
+        net: Math.max(0, gross - discountTotal),
+        appliedRules,
+        perks: dedupedPerks
+    };
+}

package/dist/booking/recompute.d.ts

@@ -0,0 +1,22 @@
+import { type PaymentEntry } from './ledger.js';
+import { type BookingTotals } from './totals.js';
+import type { ParticipantPriceResult } from './participant-pricing.js';
+import type { AdjustmentSums } from './adjustments.js';
+import type { BookingStatus } from './state-machine.js';
+/** Thrown when an edit is not allowed (terminal booking). */
+export declare class BookingEditError extends Error {
+    constructor(message: string);
+}
+/**
+ * Pure recompute of a booking's money snapshot after an edit. Takes the
+ * already-computed per-participant pricing result (the caller prices from the
+ * edited or existing people/items) and folds in payments.
+ */
+export declare function recomputeTotals(result: ParticipantPriceResult, sums: AdjustmentSums, payments: PaymentEntry[]): BookingTotals;
+/** Block edits to terminal bookings (cancelled/completed). */
+export declare function assertEditAllowed(status: BookingStatus): void;
+/**
+ * Portal (self-service) edit guard: block terminal bookings AND any edit that
+ * would drop the gross below what's already paid (would owe a refund → staff).
+ */
+export declare function assertPortalEditAllowed(status: BookingStatus, newGross: number, payments: PaymentEntry[]): void;

package/dist/booking/recompute.js

@@ -0,0 +1,31 @@
+import { totalPaid, assertGrossNotBelowPaid } from './ledger.js';
+import { resultToTotals } from './totals.js';
+/** Thrown when an edit is not allowed (terminal booking). */
+export class BookingEditError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BookingEditError';
+    }
+}
+/**
+ * Pure recompute of a booking's money snapshot after an edit. Takes the
+ * already-computed per-participant pricing result (the caller prices from the
+ * edited or existing people/items) and folds in payments.
+ */
+export function recomputeTotals(result, sums, payments) {
+    return resultToTotals(result, sums, totalPaid(payments));
+}
+/** Block edits to terminal bookings (cancelled/completed). */
+export function assertEditAllowed(status) {
+    if (status === 'cancelled' || status === 'completed') {
+        throw new BookingEditError(`Cannot edit a ${status} booking`);
+    }
+}
+/**
+ * Portal (self-service) edit guard: block terminal bookings AND any edit that
+ * would drop the gross below what's already paid (would owe a refund → staff).
+ */
+export function assertPortalEditAllowed(status, newGross, payments) {
+    assertEditAllowed(status);
+    assertGrossNotBelowPaid(newGross, payments); // throws LedgerError when newGross < paid
+}

package/dist/booking/reminders-schedule.d.ts

@@ -0,0 +1,11 @@
+import type { ReminderRule } from './config.js';
+/** The earliest non-null departure across booking items, or null when none. */
+export declare function earliestDeparture(dates: Array<Date | null>): Date | null;
+/** Balance-due deadline = earliest departure − `balanceDueDaysBefore`; null if unconfigured. */
+export declare function computeBalanceDueAt(dates: Array<Date | null>, balanceDueDaysBefore: number | null): Date | null;
+/** One scheduled-reminder row per rule, anchored to the earliest departure. */
+export declare function computeReminderSchedule(dates: Array<Date | null>, rules: ReminderRule[]): Array<{
+    type: string;
+    templateKey: string;
+    scheduledFor: Date;
+}>;

package/dist/booking/reminders-schedule.js

@@ -0,0 +1,28 @@
+const MS_PER_DAY = 86_400_000;
+/** The earliest non-null departure across booking items, or null when none. */
+export function earliestDeparture(dates) {
+    const valid = dates.filter((d) => d instanceof Date);
+    if (valid.length === 0)
+        return null;
+    return valid.reduce((min, d) => (d.getTime() < min.getTime() ? d : min));
+}
+/** Balance-due deadline = earliest departure − `balanceDueDaysBefore`; null if unconfigured. */
+export function computeBalanceDueAt(dates, balanceDueDaysBefore) {
+    if (balanceDueDaysBefore == null)
+        return null;
+    const dep = earliestDeparture(dates);
+    if (!dep)
+        return null;
+    return new Date(dep.getTime() - balanceDueDaysBefore * MS_PER_DAY);
+}
+/** One scheduled-reminder row per rule, anchored to the earliest departure. */
+export function computeReminderSchedule(dates, rules) {
+    const dep = earliestDeparture(dates);
+    if (!dep || rules.length === 0)
+        return [];
+    return rules.map((r) => ({
+        type: r.type,
+        templateKey: r.templateKey,
+        scheduledFor: new Date(dep.getTime() - r.daysBefore * MS_PER_DAY)
+    }));
+}