includio-cms 0.36.9 → 0.37.0

package/dist/booking/participant-fields/access.js

@@ -0,0 +1,14 @@
+/**
+ * Whether a given audience may fill/edit a field. Default `whoFills` is `'both'`.
+ *
+ * Staff (admin) is **privileged** — it may edit every field regardless of
+ * `whoFills` (operators must always be able to correct/complete any datum).
+ * `whoFills` therefore only gates the **customer/portal** side: a `'staff'`
+ * field is simply hidden from the portal, not locked away from the operator.
+ */
+export function canFill(field, audience) {
+    if (audience === 'staff')
+        return true;
+    const who = field.whoFills ?? 'both';
+    return who === 'both' || who === 'customer';
+}

package/dist/booking/participant-fields/age.d.ts

@@ -0,0 +1,12 @@
+import type { FieldDef, AgeFlagConfig } from './types.js';
+/** Pełne lata między `dob` a `anchor`. `null` gdy data niepoprawna. */
+export declare function ageAt(dob: string, anchor: Date): number | null;
+/**
+ * Generyczna flaga wieku — bez magicznego klucza. Bierze pole z rolą `birthDate`,
+ * liczy wiek na `anchorDate` (data wylotu) i flaguje gdy < `config.below`.
+ * Brak configu / kotwicy / pola-roli / wartości ⇒ `{ flagged: false, age: null }`.
+ */
+export declare function deriveAgeFlag(data: Record<string, unknown>, fields: FieldDef[], config: AgeFlagConfig | null, anchorDate: Date | null): {
+    flagged: boolean;
+    age: number | null;
+};

package/dist/booking/participant-fields/age.js

@@ -0,0 +1,28 @@
+/** Pełne lata między `dob` a `anchor`. `null` gdy data niepoprawna. */
+export function ageAt(dob, anchor) {
+    if (typeof dob !== 'string' || Number.isNaN(Date.parse(dob)))
+        return null;
+    const d = new Date(dob);
+    let age = anchor.getUTCFullYear() - d.getUTCFullYear();
+    const m = anchor.getUTCMonth() - d.getUTCMonth();
+    if (m < 0 || (m === 0 && anchor.getUTCDate() < d.getUTCDate()))
+        age--;
+    return age;
+}
+/**
+ * Generyczna flaga wieku — bez magicznego klucza. Bierze pole z rolą `birthDate`,
+ * liczy wiek na `anchorDate` (data wylotu) i flaguje gdy < `config.below`.
+ * Brak configu / kotwicy / pola-roli / wartości ⇒ `{ flagged: false, age: null }`.
+ */
+export function deriveAgeFlag(data, fields, config, anchorDate) {
+    if (!config || !anchorDate)
+        return { flagged: false, age: null };
+    const dobField = fields.find((f) => f.role === 'birthDate');
+    if (!dobField)
+        return { flagged: false, age: null };
+    const raw = data[dobField.key];
+    if (typeof raw !== 'string')
+        return { flagged: false, age: null };
+    const age = ageAt(raw, anchorDate);
+    return { flagged: age !== null && age < config.below, age };
+}

package/dist/booking/participant-fields/completeness.d.ts

@@ -0,0 +1,8 @@
+import type { FieldDef } from './types.js';
+export interface Completeness {
+    filled: number;
+    total: number;
+    missing: string[];
+    complete: boolean;
+}
+export declare function completeness(data: Record<string, unknown>, fields: FieldDef[]): Completeness;

package/dist/booking/participant-fields/completeness.js

@@ -0,0 +1,13 @@
+function isEmpty(v) {
+    return v === undefined || v === null || v === '';
+}
+export function completeness(data, fields) {
+    const required = fields.filter((f) => f.required);
+    const missing = required.filter((f) => isEmpty(data[f.key])).map((f) => f.label);
+    return {
+        filled: required.length - missing.length,
+        total: required.length,
+        missing,
+        complete: missing.length === 0
+    };
+}

package/dist/booking/participant-fields/group.d.ts

@@ -0,0 +1,6 @@
+import type { FieldDef } from './types.js';
+export interface FieldGroup {
+    section: string | null;
+    fields: FieldDef[];
+}
+export declare function groupBySection(fields: FieldDef[]): FieldGroup[];

package/dist/booking/participant-fields/group.js

@@ -0,0 +1,15 @@
+export function groupBySection(fields) {
+    const groups = [];
+    const index = new Map();
+    for (const f of fields) {
+        const key = f.section ?? null;
+        let g = index.get(key);
+        if (!g) {
+            g = { section: key, fields: [] };
+            index.set(key, g);
+            groups.push(g);
+        }
+        g.fields.push(f);
+    }
+    return groups;
+}

package/dist/booking/participant-fields/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './validate.js';
+export * from './completeness.js';
+export * from './age.js';
+export * from './group.js';
+export * from './access.js';

package/dist/booking/participant-fields/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './validate.js';
+export * from './completeness.js';
+export * from './age.js';
+export * from './group.js';
+export * from './access.js';

package/dist/booking/participant-fields/types.d.ts

@@ -0,0 +1,50 @@
+/** Paleta typów pól v1. Rozszerzalna przez dopisanie typu + renderera/walidatora. */
+export declare const FIELD_TYPES: readonly ["text", "number", "boolean", "select", "date"];
+export type FieldType = (typeof FIELD_TYPES)[number];
+export declare function isFieldType(v: unknown): v is FieldType;
+/** Kto wypełnia pole. Default 'both'. */
+export type WhoFills = 'customer' | 'staff' | 'both';
+/**
+ * Generyczna „rola" pola — opcjonalna wskazówka semantyczna, którą UI/logika
+ * mogą wykorzystać bez magicznych kluczy:
+ * - `name` — wartość użyta jako tytuł karty uczestnika,
+ * - `birthDate` — pole daty będące podstawą flagi wieku (patrz {@link AgeFlagConfig}).
+ */
+export type FieldRole = 'name' | 'birthDate';
+/** Serializowalna definicja pojedynczego pola uczestnika. */
+export interface FieldDef {
+    /** Stabilny klucz w `participant.data`. */
+    key: string;
+    label: string;
+    type: FieldType;
+    required?: boolean;
+    /** Dla `select`. */
+    options?: string[];
+    /** Grupowanie w UI (np. "Podstawowe", "Ankieta"). */
+    section?: string;
+    /** Kto wypełnia (default 'both'). */
+    whoFills?: WhoFills;
+    /** Opcjonalna rola semantyczna (tytuł karty / data do flagi wieku). */
+    role?: FieldRole;
+    helpText?: string;
+    /** v1 stałe 'participant'; szew pod 'reservation' później. */
+    scope?: 'participant';
+    /** Dla `number`. */
+    min?: number;
+    max?: number;
+}
+/**
+ * Generyczna flaga wieku: oznacza uczestnika, którego wiek (liczony z pola roli
+ * `birthDate` na datę-kotwicę) jest **poniżej** progu `below`. Domeno-agnostyczna —
+ * klient nadaje znaczenie przez `label` ("Dziecko", "Junior", …). Brak configu =
+ * brak flagi. Próg wieku liczony na datę wylotu pozycji.
+ */
+export interface AgeFlagConfig {
+    /** Flaguj, gdy wiek < `below`. */
+    below: number;
+    /** Etykieta badge'a (domyślnie „Dziecko"/"Child"). */
+    label?: {
+        pl: string;
+        en: string;
+    };
+}

package/dist/booking/participant-fields/types.js

@@ -0,0 +1,5 @@
+/** Paleta typów pól v1. Rozszerzalna przez dopisanie typu + renderera/walidatora. */
+export const FIELD_TYPES = ['text', 'number', 'boolean', 'select', 'date'];
+export function isFieldType(v) {
+    return typeof v === 'string' && FIELD_TYPES.includes(v);
+}

package/dist/booking/participant-fields/validate.d.ts

@@ -0,0 +1,7 @@
+import type { FieldDef } from './types.js';
+export interface FieldError {
+    key: string;
+    code: 'required' | 'type' | 'min' | 'max' | 'option';
+    message: string;
+}
+export declare function validateAgainstSchema(data: Record<string, unknown>, fields: FieldDef[]): FieldError[];

package/dist/booking/participant-fields/validate.js

@@ -0,0 +1,44 @@
+function isEmpty(v) {
+    return v === undefined || v === null || v === '';
+}
+export function validateAgainstSchema(data, fields) {
+    const errors = [];
+    for (const f of fields) {
+        const v = data[f.key];
+        if (isEmpty(v)) {
+            if (f.required)
+                errors.push({ key: f.key, code: 'required', message: `${f.label} jest wymagane` });
+            continue; // puste opcjonalne = OK, nie typujemy
+        }
+        switch (f.type) {
+            case 'text':
+                if (typeof v !== 'string')
+                    errors.push({ key: f.key, code: 'type', message: `${f.label}: oczekiwano tekstu` });
+                break;
+            case 'boolean':
+                if (typeof v !== 'boolean')
+                    errors.push({ key: f.key, code: 'type', message: `${f.label}: oczekiwano tak/nie` });
+                break;
+            case 'date':
+                if (typeof v !== 'string' || Number.isNaN(Date.parse(v)))
+                    errors.push({ key: f.key, code: 'type', message: `${f.label}: niepoprawna data` });
+                break;
+            case 'select':
+                if (!(f.options ?? []).includes(String(v)))
+                    errors.push({ key: f.key, code: 'option', message: `${f.label}: niedozwolona wartość` });
+                break;
+            case 'number': {
+                if (typeof v !== 'number' || Number.isNaN(v)) {
+                    errors.push({ key: f.key, code: 'type', message: `${f.label}: oczekiwano liczby` });
+                    break;
+                }
+                if (f.min !== undefined && v < f.min)
+                    errors.push({ key: f.key, code: 'min', message: `${f.label}: min ${f.min}` });
+                if (f.max !== undefined && v > f.max)
+                    errors.push({ key: f.key, code: 'max', message: `${f.label}: max ${f.max}` });
+                break;
+            }
+        }
+    }
+    return errors;
+}

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