includio-cms 0.36.8 → 0.37.0

package/dist/booking/draft.js

@@ -0,0 +1,67 @@
+import { computeBalanceDueAt, computeReminderSchedule } from './reminders-schedule.js';
+import { priceByParticipant } from './participant-pricing.js';
+import { resultToTotals, grossByTripRef } from './totals.js';
+import { NO_ADJUSTMENTS } from './adjustments.js';
+/** Build the per-participant pricing inputs from a create payload. */
+export function pricingInputsFromCreate(input, identityFields) {
+    const dobKey = identityFields.find((f) => f.role === 'birthDate')?.key ?? null;
+    const seen = new Set();
+    const trips = [];
+    for (const it of input.items) {
+        if (seen.has(it.tripRef))
+            continue;
+        seen.add(it.tripRef);
+        trips.push({ ref: it.tripRef, adultPrice: it.unitPrice });
+    }
+    const tripsByPersonRef = new Map();
+    for (const it of input.items) {
+        for (const a of it.assignments) {
+            const list = tripsByPersonRef.get(a.personRef);
+            if (list) {
+                if (!list.includes(it.tripRef))
+                    list.push(it.tripRef);
+            }
+            else {
+                tripsByPersonRef.set(a.personRef, [it.tripRef]);
+            }
+        }
+    }
+    const participants = input.persons.map((p) => {
+        const dobRaw = dobKey ? p.identity[dobKey] : null;
+        return {
+            id: p.ref,
+            dob: typeof dobRaw === 'string' ? dobRaw : null,
+            tripRefs: tripsByPersonRef.get(p.ref) ?? []
+        };
+    });
+    return { participants, trips };
+}
+/**
+ * Pure: turn a create payload + config + pricing context + clock into the
+ * rows/totals to persist. Prices per-participant (age bands + volume ladder +
+ * early-bird), anchored to the arrival date in `ctx.anchor`.
+ */
+export function buildBookingDraft(input, config, ctx, now) {
+    const dates = input.items.map((it) => it.departureDate);
+    const { participants, trips } = pricingInputsFromCreate(input, ctx.identityFields);
+    const result = priceByParticipant(participants, trips, ctx.anchor, now, ctx.participantPricing);
+    const totals = resultToTotals(result, NO_ADJUSTMENTS, 0);
+    const subtotalByRef = grossByTripRef(result);
+    const items = input.items.map((it) => ({
+        tripRef: it.tripRef,
+        departureDate: it.departureDate,
+        participantsCount: it.assignments.length,
+        unitPriceSnapshot: it.unitPrice,
+        subtotalSnapshot: subtotalByRef.get(it.tripRef) ?? null,
+        appliedDiscounts: totals.appliedRules.filter((r) => r.targetRef === it.tripRef),
+        assignments: it.assignments
+    }));
+    return {
+        totals,
+        persons: input.persons,
+        items,
+        reminders: computeReminderSchedule(dates, config.reminders),
+        balanceDueAt: computeBalanceDueAt(dates, config.balanceDueDaysBefore),
+        holdExpiresAt: new Date(now.getTime() + config.depositTtlMinutes * 60_000)
+    };
+}

package/dist/booking/expiry-logic.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure decision helpers for the booking maintenance cron. No clock/db access —
+ * the caller passes `now` and the rows. Tested in isolation; the DB wrappers in
+ * `server/maintenance.ts` just fetch rows and apply the results.
+ */
+import type { BookingStatus } from './state-machine.js';
+/** Ids of reminders that are due to send (unsent and `scheduledFor <= now`). */
+export declare function selectDueReminders(rows: Array<{
+    id: string;
+    scheduledFor: Date;
+    sentAt: Date | null;
+}>, now: Date): string[];
+/**
+ * Partition active bookings into those to auto-cancel:
+ *  - `abandon`: a `draft` whose deposit hold (`holdExpiresAt`) has lapsed.
+ *  - `forfeit`: any non-terminal booking past `balanceDueAt` with balance left
+ *    (deposit forfeited). `paid`/`completed`/`cancelled` are skipped.
+ */
+export declare function decideExpirations(bookings: Array<{
+    id: string;
+    status: BookingStatus;
+    holdExpiresAt: Date | null;
+    balanceDueAt: Date | null;
+    totals: {
+        balance: number;
+    };
+}>, now: Date): {
+    abandon: string[];
+    forfeit: string[];
+};

package/dist/booking/expiry-logic.js

@@ -0,0 +1,33 @@
+/**
+ * Pure decision helpers for the booking maintenance cron. No clock/db access —
+ * the caller passes `now` and the rows. Tested in isolation; the DB wrappers in
+ * `server/maintenance.ts` just fetch rows and apply the results.
+ */
+/** Ids of reminders that are due to send (unsent and `scheduledFor <= now`). */
+export function selectDueReminders(rows, now) {
+    return rows
+        .filter((r) => r.sentAt == null && r.scheduledFor.getTime() <= now.getTime())
+        .map((r) => r.id);
+}
+/**
+ * Partition active bookings into those to auto-cancel:
+ *  - `abandon`: a `draft` whose deposit hold (`holdExpiresAt`) has lapsed.
+ *  - `forfeit`: any non-terminal booking past `balanceDueAt` with balance left
+ *    (deposit forfeited). `paid`/`completed`/`cancelled` are skipped.
+ */
+export function decideExpirations(bookings, now) {
+    const abandon = [];
+    const forfeit = [];
+    for (const b of bookings) {
+        if (b.status === 'cancelled' || b.status === 'completed' || b.status === 'paid')
+            continue;
+        if (b.status === 'draft' && b.holdExpiresAt && b.holdExpiresAt.getTime() <= now.getTime()) {
+            abandon.push(b.id);
+            continue;
+        }
+        if (b.balanceDueAt && b.balanceDueAt.getTime() <= now.getTime() && b.totals.balance > 0) {
+            forfeit.push(b.id);
+        }
+    }
+    return { abandon, forfeit };
+}

package/dist/booking/index.d.ts

@@ -0,0 +1,18 @@
+import type { CMSModule } from '../types/modules.js';
+import { type BookingConfig } from './config.js';
+/**
+ * Defines the booking module — a long-lived, mutable reservation system with a
+ * payment ledger, layered on the CMS core as a {@link CMSModule}. The resolved
+ * config is reachable via `getCMS().getModuleConfig('booking')`.
+ *
+ * @public
+ */
+export declare function defineBooking(config: BookingConfig): CMSModule;
+export { type BookingConfig, type ResolvedBookingConfig, type ReminderRule, type BookingValidator, type BookingValidationContext } from './config.js';
+export { price, daysUntil, type Condition, type Effect, type DiscountRule, type PricingConfig, type PricingLine, type AppliedRule, type Perk, type PriceResult } from './pricing.js';
+export { priceByParticipant, bandPctFor, ladderTierFor, type AgeBand, type LadderTier, type EarlyBird, type ParticipantPricingConfig, type PricedTrip, type PricingParticipant, type ParticipantLine, type ParticipantBreakdown, type ParticipantPriceResult } from './participant-pricing.js';
+export { buildPricingInputs, type PersonRow, type ItemRow, type ItemPersonRow, type PricingInputs } from './pricing-inputs.js';
+export { deriveStatus, canTransition, assertTransition, BookingStateError, BOOKING_STATUSES, type BookingStatus } from './state-machine.js';
+export { signedAmount, sumAdjustments, assertAdjustmentMagnitude, NO_ADJUSTMENTS, type AdjustmentKind, type BookingAdjustment, type AdjustmentSums } from './adjustments.js';
+export { totalPaid, totalRefunded, totalPending, balance, isFullyPaid, canReduceGrossTo, assertGrossNotBelowPaid, ledgerSummary, LedgerError, type PaymentEntry, type PaymentKind, type PaymentStatus, type LedgerSummary } from './ledger.js';
+export * from './participant-fields/index.js';

package/dist/booking/index.js

@@ -0,0 +1,52 @@
+import { resolveBookingConfig } from './config.js';
+/**
+ * Defines the booking module — a long-lived, mutable reservation system with a
+ * payment ledger, layered on the CMS core as a {@link CMSModule}. The resolved
+ * config is reachable via `getCMS().getModuleConfig('booking')`.
+ *
+ * @public
+ */
+export function defineBooking(config) {
+    const resolved = resolveBookingConfig(config);
+    // Katalog + kolekcje wspierające booking (np. typy wypraw definiujące pola uczestnika).
+    // Pusta lista ⇒ `undefined`, żeby nie zmieniać semantyki „brak wciągniętych kolekcji".
+    const surfaced = [
+        ...(resolved.catalogCollection ? [resolved.catalogCollection] : []),
+        ...resolved.surfacedCollections
+    ];
+    return {
+        id: 'booking',
+        label: { pl: 'Rezerwacje', en: 'Bookings' },
+        icon: 'calendar',
+        context: {
+            contextLabel: { pl: 'Rezerwacje', en: 'Bookings' },
+            landingUrl: '/admin/booking',
+            sections: [
+                {
+                    key: 'reservations',
+                    title: { pl: 'Rezerwacje', en: 'Reservations' },
+                    url: '/admin/booking/reservations',
+                    icon: 'clipboard-list'
+                }
+            ],
+            surfacedCollections: surfaced.length > 0 ? surfaced : undefined
+        },
+        config: resolved,
+        serverHooks: {
+            // A plain string, NOT an inline import: this barrel is client-safe (re-exported
+            // via `includio-cms/booking`), and inlining `import('./server/...')` here makes
+            // client bundlers pull server-only code (node:fs/url via the email template
+            // registry) and break browser builds. `initCMS` (server-only) imports this
+            // specifier at runtime and runs its `serverInit` — see ModuleServerHooks.initModule.
+            initModule: 'includio-cms/booking/server'
+        }
+    };
+}
+export {} from './config.js';
+export { price, daysUntil } from './pricing.js';
+export { priceByParticipant, bandPctFor, ladderTierFor } from './participant-pricing.js';
+export { buildPricingInputs } from './pricing-inputs.js';
+export { deriveStatus, canTransition, assertTransition, BookingStateError, BOOKING_STATUSES } from './state-machine.js';
+export { signedAmount, sumAdjustments, assertAdjustmentMagnitude, NO_ADJUSTMENTS } from './adjustments.js';
+export { totalPaid, totalRefunded, totalPending, balance, isFullyPaid, canReduceGrossTo, assertGrossNotBelowPaid, ledgerSummary, LedgerError } from './ledger.js';
+export * from './participant-fields/index.js';

package/dist/booking/ledger.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Booking payment ledger — pure helpers over a list of payment entries. The
+ * ledger is the source of truth for "how much is paid"; the booking status is
+ * {@link import('./state-machine.js').deriveStatus | derived} from the balance.
+ *
+ * All amounts are in **minor units** (grosze).
+ */
+export type PaymentKind = 'deposit' | 'installment' | 'cash' | 'online';
+export type PaymentStatus = 'pending' | 'paid' | 'failed' | 'refunded';
+export interface PaymentEntry {
+    amount: number;
+    status: PaymentStatus;
+    kind?: PaymentKind;
+}
+/** Thrown when an edit would push the gross below what has already been paid. */
+export declare class LedgerError extends Error {
+    constructor(message: string);
+}
+/** Sum of entries currently in `paid` state. */
+export declare function totalPaid(payments: PaymentEntry[]): number;
+/** Sum of entries that were refunded. */
+export declare function totalRefunded(payments: PaymentEntry[]): number;
+/** Sum of entries still pending (links generated, not yet settled). */
+export declare function totalPending(payments: PaymentEntry[]): number;
+/** Outstanding balance: `gross − paid` (never below 0). */
+export declare function balance(gross: number, payments: PaymentEntry[]): number;
+/** Whether the booking is fully settled (`gross > 0` and balance reached 0). */
+export declare function isFullyPaid(gross: number, payments: PaymentEntry[]): boolean;
+/** Whether the gross may be reduced to `newGross` without going below paid. */
+export declare function canReduceGrossTo(newGross: number, payments: PaymentEntry[]): boolean;
+/**
+ * Asserts an edit's new gross does not drop below the already-paid total.
+ * @throws {LedgerError} when `newGross < totalPaid`.
+ */
+export declare function assertGrossNotBelowPaid(newGross: number, payments: PaymentEntry[]): void;
+export interface LedgerSummary {
+    gross: number;
+    paid: number;
+    pending: number;
+    refunded: number;
+    balance: number;
+    /** Amount paid beyond gross (e.g. after a downward edit), 0 when none. */
+    overpaid: number;
+}
+/** Full ledger snapshot for a given gross. */
+export declare function ledgerSummary(gross: number, payments: PaymentEntry[]): LedgerSummary;

package/dist/booking/ledger.js

@@ -0,0 +1,60 @@
+/**
+ * Booking payment ledger — pure helpers over a list of payment entries. The
+ * ledger is the source of truth for "how much is paid"; the booking status is
+ * {@link import('./state-machine.js').deriveStatus | derived} from the balance.
+ *
+ * All amounts are in **minor units** (grosze).
+ */
+/** Thrown when an edit would push the gross below what has already been paid. */
+export class LedgerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LedgerError';
+    }
+}
+/** Sum of entries currently in `paid` state. */
+export function totalPaid(payments) {
+    return payments.reduce((sum, p) => (p.status === 'paid' ? sum + p.amount : sum), 0);
+}
+/** Sum of entries that were refunded. */
+export function totalRefunded(payments) {
+    return payments.reduce((sum, p) => (p.status === 'refunded' ? sum + p.amount : sum), 0);
+}
+/** Sum of entries still pending (links generated, not yet settled). */
+export function totalPending(payments) {
+    return payments.reduce((sum, p) => (p.status === 'pending' ? sum + p.amount : sum), 0);
+}
+/** Outstanding balance: `gross − paid` (never below 0). */
+export function balance(gross, payments) {
+    return Math.max(0, gross - totalPaid(payments));
+}
+/** Whether the booking is fully settled (`gross > 0` and balance reached 0). */
+export function isFullyPaid(gross, payments) {
+    return gross > 0 && totalPaid(payments) >= gross;
+}
+/** Whether the gross may be reduced to `newGross` without going below paid. */
+export function canReduceGrossTo(newGross, payments) {
+    return newGross >= totalPaid(payments);
+}
+/**
+ * Asserts an edit's new gross does not drop below the already-paid total.
+ * @throws {LedgerError} when `newGross < totalPaid`.
+ */
+export function assertGrossNotBelowPaid(newGross, payments) {
+    const paid = totalPaid(payments);
+    if (newGross < paid) {
+        throw new LedgerError(`Cannot set gross to ${newGross}: already paid ${paid} (would owe a refund of ${paid - newGross}).`);
+    }
+}
+/** Full ledger snapshot for a given gross. */
+export function ledgerSummary(gross, payments) {
+    const paid = totalPaid(payments);
+    return {
+        gross,
+        paid,
+        pending: totalPending(payments),
+        refunded: totalRefunded(payments),
+        balance: Math.max(0, gross - paid),
+        overpaid: Math.max(0, paid - gross)
+    };
+}

package/dist/booking/number.d.ts

@@ -0,0 +1,2 @@
+/** Random `BK-XXXXX` booking number (~25 bits). Caller retries on UNIQUE collision. */
+export declare function generateBookingNumber(): string;

package/dist/booking/number.js

@@ -0,0 +1,11 @@
+// Crockford base32 alphabet — unambiguous (no I, L, O, U).
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+/** Random `BK-XXXXX` booking number (~25 bits). Caller retries on UNIQUE collision. */
+export function generateBookingNumber() {
+    const bytes = new Uint8Array(5);
+    crypto.getRandomValues(bytes);
+    let out = '';
+    for (let i = 0; i < 5; i++)
+        out += ALPHABET[bytes[i] % 32];
+    return `BK-${out}`;
+}

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

@@ -0,0 +1,10 @@
+import type { FieldDef } from './types.js';
+/**
+ * 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 declare function canFill(field: FieldDef, audience: 'customer' | 'staff'): boolean;

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