@almatar/smart-booking-dashboard 0.0.2-alpha.2 → 0.0.2-alpha.3

package/esm2022/lib/components/reissue-dialog/reissue.store.mjs

@@ -0,0 +1,349 @@
+import { Injectable, computed, inject, signal } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { EMPTY, Subject, of, throwError } from 'rxjs';
+import { catchError, debounceTime, distinctUntilChanged, switchMap, tap } from 'rxjs/operators';
+import { SBD_CONFIG } from '../../config/dashboard.config';
+import { SbdReissueService } from '../../services/reissue.service';
+import { buildReissueBookingContext, buildReissueSearchUrl } from '../../utils/reissue-url.builder';
+import { destinationAirport, formatReissueDate, formatShortDate, formatTime, isLegFlown, legTitle, originAirport, todayIso, } from '../../utils/reissue-format';
+import * as i0 from "@angular/core";
+export function buildLegRow(leg, available, selected, unavailableReason = 'offline') {
+    const flown = isLegFlown(leg);
+    return {
+        leg,
+        direction: leg.direction,
+        from: leg.originCode,
+        to: leg.destinationCode,
+        dateLabel: formatShortDate(leg.departure),
+        depTime: formatTime(leg.departure),
+        arrTime: formatTime(leg.arrival),
+        stopsLabel: leg.stops > 0 ? `${leg.stops} stop${leg.stops > 1 ? 's' : ''}` : 'Direct',
+        airlineLine: [leg.airline, leg.flightNo].filter(Boolean).join(' · '),
+        flown,
+        available: available && !flown,
+        reason: flown ? 'flown' : available ? null : unavailableReason,
+        selected: selected && !flown,
+    };
+}
+const START_ERROR = 'Could not start the reissue request.';
+const AVAILABILITY_ERROR = 'Could not check availability for this booking.';
+/** `base (HTTP 500: message from the backend)` — so the agent (and we, while the APIs are new) can see why it failed. */
+function describeHttpError(base, e) {
+    const err = e;
+    // The backend sends both: `error` (the real reason, e.g. "Unauthorized!") and a generic `message`.
+    const body = typeof err?.error === 'string' ? [err.error] : [err?.error?.error, err?.error?.message];
+    const text = body.filter(Boolean).join(' — ').slice(0, 200);
+    const detail = [err?.status ? `HTTP ${err.status}` : '', text].filter(Boolean).join(': ');
+    return detail ? `${base} (${detail})` : base;
+}
+/**
+ * State + rules of the Reissue dialog (one instance per dialog, provided by the dialog component).
+ * The step components are presentational: they get view models from here through the dialog shell.
+ */
+export class SbdReissueStore {
+    constructor() {
+        this.api = inject(SbdReissueService);
+        this.config = inject(SBD_CONFIG);
+        this.today = todayIso();
+        // ── state ─────────────────────────────────────────────────────────────────
+        this.booking = signal(null);
+        this.step = signal('service');
+        this.loading = signal(false);
+        this.error = signal(null);
+        this.postBookingId = signal('');
+        this.service = signal(null);
+        /** Raw upgrade-class response; `null` when not loaded / not offered. Read by `SbdReissueUpgradeStore`. */
+        this.upgradeOptions = signal(null);
+        this.upgradeAvailable = computed(() => this.api.hasUpgradeOptions(this.upgradeOptions()));
+        this.availableIds = signal(new Set());
+        /** The availability call answered (so "no leg available" is a real answer, not "still loading"). */
+        this.availabilityLoaded = signal(false);
+        this.selectedLegIds = signal([]);
+        /** The "select flight" step was skipped (one-way): Back from the edit step returns to the service list. */
+        this.legsStepSkipped = signal(false);
+        this.dateEdits = signal({});
+        this.routeEdits = signal({});
+        this.searchedAirports = signal([]);
+        this.load$ = new Subject();
+        this.airportTerm$ = new Subject();
+        // ── derived ───────────────────────────────────────────────────────────────
+        this.ctx = computed(() => {
+            const b = this.booking();
+            return b ? buildReissueBookingContext(b.data, b.id) : null;
+        });
+        this.legs = computed(() => this.ctx()?.legs ?? []);
+        this.selectedSet = computed(() => new Set(this.selectedLegIds()));
+        this.selectedLegs = computed(() => this.legs().filter(l => this.selectedSet().has(l.legId)));
+        this.legRows = computed(() => this.legs().map(leg => buildLegRow(leg, this.availableIds().has(leg.legId), this.selectedSet().has(leg.legId))));
+        /** `false` = a round trip must be upgraded as a whole (availability's `allowCustomerToSelectSingleLeg`). */
+        this.allowSingleLegSelection = signal(true);
+        this.anyAvailable = computed(() => this.legRows().some(r => r.available));
+        /**
+         * No leg can be reissued online (offline, or already flown): the dialog shows this message instead of the options,
+         * like the cancel dialog does for a booking it cannot auto-cancel. `null` while loading or when any leg is available.
+         */
+        this.blocked = computed(() => {
+            const rows = this.legRows();
+            if (!this.availabilityLoaded() || !rows.length || rows.some(r => r.available))
+                return null;
+            return rows.every(r => r.flown)
+                ? { title: 'All flights of this booking have already departed.', text: 'There is nothing left to reissue.' }
+                : {
+                    title: 'This booking doesn’t support online reissue.',
+                    text: 'Please escalate to the relevant team for manual handling.',
+                };
+        });
+        this.canContinue = computed(() => this.selectedLegIds().length > 0);
+        /** A leg's date after the change: the new one when the agent is changing it, the original otherwise. */
+        this.dateRows = computed(() => {
+            const legs = this.legs();
+            const selected = this.selectedSet();
+            const edits = this.dateEdits();
+            const effective = (l) => (selected.has(l.legId) ? (edits[l.legId] ?? '') : l.departure.slice(0, 10));
+            return legs.flatMap((leg, i) => {
+                if (!selected.has(leg.legId))
+                    return [];
+                const prev = i > 0 ? effective(legs[i - 1]) : '';
+                return [
+                    {
+                        leg,
+                        title: legTitle(leg),
+                        current: formatReissueDate(leg.departure),
+                        value: edits[leg.legId] ?? '',
+                        // Never before today or the previous leg; never after the next leg (same day is fine).
+                        min: prev > this.today ? prev : this.today,
+                        max: i < legs.length - 1 ? effective(legs[i + 1]) : '',
+                    },
+                ];
+            });
+        });
+        this.routeRows = computed(() => {
+            const edits = this.routeEdits();
+            return this.selectedLegs().map(leg => ({
+                leg,
+                title: legTitle(leg),
+                current: formatReissueDate(leg.departure),
+                origin: edits[leg.legId]?.origin ?? originAirport(leg),
+                destination: edits[leg.legId]?.destination ?? destinationAirport(leg),
+            }));
+        });
+        this.airportOptions = computed(() => {
+            const byId = new Map();
+            // Order matters (later wins): the booking's own airports, the search results, then what is already picked.
+            for (const l of this.legs()) {
+                byId.set(l.originCode, originAirport(l));
+                byId.set(l.destinationCode, destinationAirport(l));
+            }
+            for (const a of this.searchedAirports())
+                byId.set(a.id, a);
+            for (const e of Object.values(this.routeEdits())) {
+                byId.set(e.origin.id, e.origin);
+                byId.set(e.destination.id, e.destination);
+            }
+            return [...byId.values()].map(a => ({ ...a, label: `${a.city_name} (${a.id}) – ${a.name}` }));
+        });
+        this.validationError = computed(() => {
+            const service = this.service();
+            if (!service || !this.selectedLegIds().length)
+                return 'Select at least one leg.';
+            if (service === 'change_date') {
+                for (const { leg, value, min, max } of this.dateRows()) {
+                    const who = leg.direction || 'This leg';
+                    if (!value)
+                        return 'Pick a new date for every selected leg.';
+                    if (value < this.today)
+                        return 'The new date cannot be in the past.';
+                    if (value < min)
+                        return `${who} cannot depart before the previous flight (${min}).`;
+                    if (max && value > max)
+                        return `${who} cannot depart after the next flight (${max}).`;
+                }
+                return null;
+            }
+            let changed = false;
+            for (const { leg, origin, destination } of this.routeRows()) {
+                if (origin.id === destination.id)
+                    return 'Origin and destination must be different.';
+                if (origin.id !== leg.originCode || destination.id !== leg.destinationCode)
+                    changed = true;
+            }
+            return changed ? null : 'Change at least one airport.';
+        });
+        this.load$.pipe(switchMap(() => this.loadFlow()), takeUntilDestroyed()).subscribe();
+        // Debounced typeahead: one request per pause in typing, older in-flight ones are dropped.
+        this.airportTerm$
+            .pipe(debounceTime(250), distinctUntilChanged(), switchMap(term => this.api.searchAirports(term)), takeUntilDestroyed())
+            .subscribe(list => this.searchedAirports.set(list));
+    }
+    /** The leg came back online from the availability check. */
+    isLegOnline(legId) {
+        return this.availableIds().has(legId);
+    }
+    // ── actions ───────────────────────────────────────────────────────────────
+    /** (Re)starts the dialog for a booking: clears every choice, then loads post-booking + availability. */
+    open(data, id) {
+        this.booking.set({ data, id });
+        this.step.set('service');
+        this.service.set(null);
+        this.selectedLegIds.set([]);
+        this.dateEdits.set({});
+        this.routeEdits.set({});
+        this.searchedAirports.set([]);
+        this.postBookingId.set('');
+        this.availableIds.set(new Set());
+        this.availabilityLoaded.set(false);
+        this.upgradeOptions.set(null);
+        this.load();
+    }
+    load() {
+        this.load$.next();
+    }
+    chooseService(service) {
+        if (this.loading() || this.error())
+            return;
+        this.service.set(service);
+        // A one-way with its only leg online has nothing to choose: skip "select flight" and go straight to editing.
+        // (An offline one-way still shows the step, so the agent sees why it cannot be changed.)
+        const rows = this.legRows();
+        if (rows.length === 1 && rows[0].available) {
+            this.selectedLegIds.set([rows[0].leg.legId]);
+            this.legsStepSkipped.set(true);
+            this.goToEdit();
+            return;
+        }
+        this.legsStepSkipped.set(false);
+        this.selectedLegIds.set([]);
+        this.step.set('legs');
+    }
+    toggleLeg(legId) {
+        if (!this.availableIds().has(legId))
+            return;
+        this.selectedLegIds.update(ids => (ids.includes(legId) ? ids.filter(i => i !== legId) : [...ids, legId]));
+    }
+    /** Legs -> edit: seed each selected leg with its current date / airports. */
+    goToEdit() {
+        if (!this.canContinue())
+            return;
+        if (this.service() === 'change_date') {
+            this.dateEdits.update(edits => {
+                const next = { ...edits };
+                for (const l of this.selectedLegs())
+                    next[l.legId] ??= l.departure.slice(0, 10);
+                return next;
+            });
+        }
+        else {
+            this.routeEdits.update(edits => {
+                const next = { ...edits };
+                for (const l of this.selectedLegs()) {
+                    next[l.legId] ??= { origin: originAirport(l), destination: destinationAirport(l) };
+                }
+                return next;
+            });
+        }
+        this.step.set('edit');
+    }
+    goTo(step) {
+        this.step.set(step);
+    }
+    back() {
+        const previous = {
+            service: 'service',
+            legs: 'service',
+            edit: this.legsStepSkipped() ? 'service' : 'legs',
+            'upgrade-legs': 'service',
+            upgrade: 'service', // the upgrade store overrides this when the leg step was shown
+            confirm: 'upgrade',
+        };
+        this.step.update(s => previous[s]);
+    }
+    setDate(legId, date) {
+        this.dateEdits.update(edits => ({ ...edits, [legId]: date }));
+    }
+    setAirport(legId, side, airport) {
+        if (!airport)
+            return;
+        const current = this.routeRows().find(r => r.leg.legId === legId);
+        if (!current)
+            return;
+        this.routeEdits.update(edits => ({
+            ...edits,
+            [legId]: { origin: current.origin, destination: current.destination, [side]: airport },
+        }));
+    }
+    /** Swaps a leg's origin and destination (the arrow between the two pickers). */
+    swapAirports(legId) {
+        const current = this.routeRows().find(r => r.leg.legId === legId);
+        if (!current)
+            return;
+        this.routeEdits.update(edits => ({
+            ...edits,
+            [legId]: { origin: current.destination, destination: current.origin },
+        }));
+    }
+    searchAirports(term) {
+        this.airportTerm$.next(term ?? '');
+    }
+    /** The web search URL for the current choices, or `null` when they are not valid yet. */
+    searchUrl() {
+        const ctx = this.ctx();
+        const service = this.service();
+        if (!ctx || !service || service === 'upgrade_class' || this.validationError())
+            return null;
+        const selection = {
+            service,
+            legs: service === 'change_date'
+                ? this.dateRows().map(r => ({ legId: r.leg.legId, departDate: r.value }))
+                : this.routeRows().map(r => ({ legId: r.leg.legId, origin: r.origin, destination: r.destination })),
+        };
+        return buildReissueSearchUrl(this.config.webBaseUrl, ctx, selection, this.postBookingId());
+    }
+    // ── loading: post-booking -> availability -> upgrade options (once per dialog visit) ─────────
+    loadFlow() {
+        const ctx = this.ctx();
+        if (!ctx) {
+            this.error.set('This booking has no leg data to reissue.');
+            return EMPTY;
+        }
+        this.loading.set(true);
+        this.error.set(null);
+        return this.api.createPostBooking(ctx.bookingId).pipe(switchMap(postBookingId => {
+            if (!postBookingId)
+                return throwError(() => START_ERROR);
+            this.postBookingId.set(postBookingId);
+            return this.api.getAvailability(ctx.bookingId, postBookingId, ctx).pipe(catchError(e => throwError(() => describeHttpError(AVAILABILITY_ERROR, e))), tap(res => {
+                // A leg that already flew can never be changed, whatever availability says: treat it as offline.
+                const flown = new Set(ctx.legs.filter(isLegFlown).map(l => l.legId));
+                this.availableIds.set(new Set((res?.data?.legs ?? []).filter(l => l.available && !flown.has(l.legId)).map(l => l.legId)));
+                this.allowSingleLegSelection.set(res?.data?.allowCustomerToSelectSingleLeg ?? true);
+                this.availabilityLoaded.set(true);
+            }), switchMap(() => this.offersUpgrade(ctx.tripType, ctx.legs, postBookingId)));
+        }), tap(options => {
+            this.upgradeOptions.set(options);
+            this.loading.set(false);
+        }), catchError((e) => {
+            this.error.set(typeof e === 'string' ? e : describeHttpError(START_ERROR, e));
+            this.loading.set(false);
+            return EMPTY;
+        }));
+    }
+    /**
+     * The upgrade-class options (same rule as the web for listing "Upgrade Class"): skipped for a one-way whose
+     * only leg is offline; a failing call just yields `null` (option hidden) instead of blocking the dialog.
+     */
+    offersUpgrade(tripType, legs, postBookingId) {
+        const ctx = this.ctx();
+        const oneWayOffline = tripType === 'OneWay' && !this.availableIds().has(legs[0]?.legId);
+        if (!ctx || !legs.length || oneWayOffline)
+            return of(null);
+        return this.api
+            .getUpgradeClassOptions(ctx.bookingId, postBookingId, ctx)
+            .pipe(catchError(() => of(null)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueStore }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reissue.store.js","sourceRoot":"","sources":["../../../../../../projects/smart-booking-dashboard/src/lib/components/reissue-dialog/reissue.store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { EMPTY, Observable, Subject, of, throwError } from 'rxjs';\nimport { catchError, debounceTime, distinctUntilChanged, map, switchMap, tap } from 'rxjs/operators';\n\nimport { SBD_CONFIG } from '../../config/dashboard.config';\nimport { SbdReissueService } from '../../services/reissue.service';\nimport {\n  ReissueAirport,\n  ReissueLeg,\n  ReissueSelection,\n  ReissueServiceKey,\n  ReissueUpgradeOptionsResponse,\n} from '../../models/reissue.types';\nimport { buildReissueBookingContext, buildReissueSearchUrl } from '../../utils/reissue-url.builder';\nimport {\n  destinationAirport,\n  formatReissueDate,\n  formatShortDate,\n  formatTime,\n  isLegFlown,\n  legTitle,\n  originAirport,\n  todayIso,\n} from '../../utils/reissue-format';\n\n/** `legs` + `edit` serve change date / route; `upgrade-legs` + `upgrade` + `confirm` serve Upgrade Class. */\nexport type ReissueStep = 'service' | 'legs' | 'edit' | 'upgrade-legs' | 'upgrade' | 'confirm';\nexport type AirportSide = 'origin' | 'destination';\nexport interface RouteEdit { origin: ReissueAirport; destination: ReissueAirport }\nexport type AirportOption = ReissueAirport & { label: string };\n\n/** View models: everything the templates need is computed here, so the templates call no methods. */\nexport interface ReissueLegRow {\n  leg: ReissueLeg;\n  direction: string;\n  from: string;\n  to: string;\n  dateLabel: string;\n  depTime: string;\n  arrTime: string;\n  stopsLabel: string;\n  airlineLine: string;\n  /** The leg already departed (\"Used Flight\"): never selectable. */\n  flown: boolean;\n  available: boolean;\n  /** Why a leg cannot be picked: it already flew, it is offline (no online reissue), or it has no upgrade options. */\n  reason: 'flown' | 'offline' | 'no-options' | null;\n  selected: boolean;\n}\n\nexport function buildLegRow(\n  leg: ReissueLeg,\n  available: boolean,\n  selected: boolean,\n  unavailableReason: 'offline' | 'no-options' = 'offline',\n): ReissueLegRow {\n  const flown = isLegFlown(leg);\n  return {\n    leg,\n    direction: leg.direction,\n    from: leg.originCode,\n    to: leg.destinationCode,\n    dateLabel: formatShortDate(leg.departure),\n    depTime: formatTime(leg.departure),\n    arrTime: formatTime(leg.arrival),\n    stopsLabel: leg.stops > 0 ? `${leg.stops} stop${leg.stops > 1 ? 's' : ''}` : 'Direct',\n    airlineLine: [leg.airline, leg.flightNo].filter(Boolean).join(' · '),\n    flown,\n    available: available && !flown,\n    reason: flown ? 'flown' : available ? null : unavailableReason,\n    selected: selected && !flown,\n  };\n}\nexport interface ReissueDateRow { leg: ReissueLeg; title: string; current: string; value: string; min: string; max: string }\nexport interface ReissueRouteRow { leg: ReissueLeg; title: string; current: string; origin: ReissueAirport; destination: ReissueAirport }\n\nconst START_ERROR = 'Could not start the reissue request.';\nconst AVAILABILITY_ERROR = 'Could not check availability for this booking.';\n\n/** `base (HTTP 500: message from the backend)` — so the agent (and we, while the APIs are new) can see why it failed. */\nfunction describeHttpError(base: string, e: unknown): string {\n  const err = e as { status?: number; error?: { message?: string; error?: string } | string } | null;\n  // The backend sends both: `error` (the real reason, e.g. \"Unauthorized!\") and a generic `message`.\n  const body =\n    typeof err?.error === 'string' ? [err.error] : [err?.error?.error, err?.error?.message];\n  const text = body.filter(Boolean).join(' — ').slice(0, 200);\n  const detail = [err?.status ? `HTTP ${err.status}` : '', text].filter(Boolean).join(': ');\n  return detail ? `${base} (${detail})` : base;\n}\n\n/**\n * State + rules of the Reissue dialog (one instance per dialog, provided by the dialog component).\n * The step components are presentational: they get view models from here through the dialog shell.\n */\n@Injectable()\nexport class SbdReissueStore {\n  private api = inject(SbdReissueService);\n  private config = inject(SBD_CONFIG);\n\n  readonly today = todayIso();\n\n  // ── state ─────────────────────────────────────────────────────────────────\n  private booking = signal<{ data: unknown; id: string } | null>(null);\n  readonly step = signal<ReissueStep>('service');\n  readonly loading = signal(false);\n  readonly error = signal<string | null>(null);\n  readonly postBookingId = signal('');\n  readonly service = signal<ReissueServiceKey | null>(null);\n  /** Raw upgrade-class response; `null` when not loaded / not offered. Read by `SbdReissueUpgradeStore`. */\n  readonly upgradeOptions = signal<ReissueUpgradeOptionsResponse | null>(null);\n  readonly upgradeAvailable = computed(() => this.api.hasUpgradeOptions(this.upgradeOptions()));\n\n  private availableIds = signal<ReadonlySet<string>>(new Set());\n  /** The availability call answered (so \"no leg available\" is a real answer, not \"still loading\"). */\n  private availabilityLoaded = signal(false);\n  private selectedLegIds = signal<readonly string[]>([]);\n  /** The \"select flight\" step was skipped (one-way): Back from the edit step returns to the service list. */\n  private legsStepSkipped = signal(false);\n  private dateEdits = signal<Readonly<Record<string, string>>>({});\n  private routeEdits = signal<Readonly<Record<string, RouteEdit>>>({});\n  private searchedAirports = signal<readonly ReissueAirport[]>([]);\n\n  private load$ = new Subject<void>();\n  private airportTerm$ = new Subject<string>();\n\n  constructor() {\n    this.load$.pipe(switchMap(() => this.loadFlow()), takeUntilDestroyed()).subscribe();\n\n    // Debounced typeahead: one request per pause in typing, older in-flight ones are dropped.\n    this.airportTerm$\n      .pipe(\n        debounceTime(250),\n        distinctUntilChanged(),\n        switchMap(term => this.api.searchAirports(term)),\n        takeUntilDestroyed(),\n      )\n      .subscribe(list => this.searchedAirports.set(list));\n  }\n\n  // ── derived ───────────────────────────────────────────────────────────────\n  readonly ctx = computed(() => {\n    const b = this.booking();\n    return b ? buildReissueBookingContext(b.data, b.id) : null;\n  });\n  readonly legs = computed(() => this.ctx()?.legs ?? []);\n  private selectedSet = computed(() => new Set(this.selectedLegIds()));\n  private selectedLegs = computed(() => this.legs().filter(l => this.selectedSet().has(l.legId)));\n\n  readonly legRows = computed<ReissueLegRow[]>(() =>\n    this.legs().map(leg => buildLegRow(leg, this.availableIds().has(leg.legId), this.selectedSet().has(leg.legId))),\n  );\n\n  /** The leg came back online from the availability check. */\n  isLegOnline(legId: string): boolean {\n    return this.availableIds().has(legId);\n  }\n\n  /** `false` = a round trip must be upgraded as a whole (availability's `allowCustomerToSelectSingleLeg`). */\n  readonly allowSingleLegSelection = signal(true);\n  readonly anyAvailable = computed(() => this.legRows().some(r => r.available));\n\n  /**\n   * No leg can be reissued online (offline, or already flown): the dialog shows this message instead of the options,\n   * like the cancel dialog does for a booking it cannot auto-cancel. `null` while loading or when any leg is available.\n   */\n  readonly blocked = computed<{ title: string; text: string } | null>(() => {\n    const rows = this.legRows();\n    if (!this.availabilityLoaded() || !rows.length || rows.some(r => r.available)) return null;\n    return rows.every(r => r.flown)\n      ? { title: 'All flights of this booking have already departed.', text: 'There is nothing left to reissue.' }\n      : {\n          title: 'This booking doesn’t support online reissue.',\n          text: 'Please escalate to the relevant team for manual handling.',\n        };\n  });\n  readonly canContinue = computed(() => this.selectedLegIds().length > 0);\n\n  /** A leg's date after the change: the new one when the agent is changing it, the original otherwise. */\n  readonly dateRows = computed<ReissueDateRow[]>(() => {\n    const legs = this.legs();\n    const selected = this.selectedSet();\n    const edits = this.dateEdits();\n    const effective = (l: ReissueLeg) => (selected.has(l.legId) ? (edits[l.legId] ?? '') : l.departure.slice(0, 10));\n\n    return legs.flatMap((leg, i) => {\n      if (!selected.has(leg.legId)) return [];\n      const prev = i > 0 ? effective(legs[i - 1]) : '';\n      return [\n        {\n          leg,\n          title: legTitle(leg),\n          current: formatReissueDate(leg.departure),\n          value: edits[leg.legId] ?? '',\n          // Never before today or the previous leg; never after the next leg (same day is fine).\n          min: prev > this.today ? prev : this.today,\n          max: i < legs.length - 1 ? effective(legs[i + 1]) : '',\n        },\n      ];\n    });\n  });\n\n  readonly routeRows = computed<ReissueRouteRow[]>(() => {\n    const edits = this.routeEdits();\n    return this.selectedLegs().map(leg => ({\n      leg,\n      title: legTitle(leg),\n      current: formatReissueDate(leg.departure),\n      origin: edits[leg.legId]?.origin ?? originAirport(leg),\n      destination: edits[leg.legId]?.destination ?? destinationAirport(leg),\n    }));\n  });\n\n  readonly airportOptions = computed<AirportOption[]>(() => {\n    const byId = new Map<string, ReissueAirport>();\n    // Order matters (later wins): the booking's own airports, the search results, then what is already picked.\n    for (const l of this.legs()) {\n      byId.set(l.originCode, originAirport(l));\n      byId.set(l.destinationCode, destinationAirport(l));\n    }\n    for (const a of this.searchedAirports()) byId.set(a.id, a);\n    for (const e of Object.values(this.routeEdits())) {\n      byId.set(e.origin.id, e.origin);\n      byId.set(e.destination.id, e.destination);\n    }\n    return [...byId.values()].map(a => ({ ...a, label: `${a.city_name} (${a.id}) – ${a.name}` }));\n  });\n\n  readonly validationError = computed<string | null>(() => {\n    const service = this.service();\n    if (!service || !this.selectedLegIds().length) return 'Select at least one leg.';\n\n    if (service === 'change_date') {\n      for (const { leg, value, min, max } of this.dateRows()) {\n        const who = leg.direction || 'This leg';\n        if (!value) return 'Pick a new date for every selected leg.';\n        if (value < this.today) return 'The new date cannot be in the past.';\n        if (value < min) return `${who} cannot depart before the previous flight (${min}).`;\n        if (max && value > max) return `${who} cannot depart after the next flight (${max}).`;\n      }\n      return null;\n    }\n\n    let changed = false;\n    for (const { leg, origin, destination } of this.routeRows()) {\n      if (origin.id === destination.id) return 'Origin and destination must be different.';\n      if (origin.id !== leg.originCode || destination.id !== leg.destinationCode) changed = true;\n    }\n    return changed ? null : 'Change at least one airport.';\n  });\n\n  // ── actions ───────────────────────────────────────────────────────────────\n\n  /** (Re)starts the dialog for a booking: clears every choice, then loads post-booking + availability. */\n  open(data: unknown, id: string): void {\n    this.booking.set({ data, id });\n    this.step.set('service');\n    this.service.set(null);\n    this.selectedLegIds.set([]);\n    this.dateEdits.set({});\n    this.routeEdits.set({});\n    this.searchedAirports.set([]);\n    this.postBookingId.set('');\n    this.availableIds.set(new Set());\n    this.availabilityLoaded.set(false);\n    this.upgradeOptions.set(null);\n    this.load();\n  }\n\n  load(): void {\n    this.load$.next();\n  }\n\n  chooseService(service: ReissueServiceKey): void {\n    if (this.loading() || this.error()) return;\n    this.service.set(service);\n    // A one-way with its only leg online has nothing to choose: skip \"select flight\" and go straight to editing.\n    // (An offline one-way still shows the step, so the agent sees why it cannot be changed.)\n    const rows = this.legRows();\n    if (rows.length === 1 && rows[0].available) {\n      this.selectedLegIds.set([rows[0].leg.legId]);\n      this.legsStepSkipped.set(true);\n      this.goToEdit();\n      return;\n    }\n    this.legsStepSkipped.set(false);\n    this.selectedLegIds.set([]);\n    this.step.set('legs');\n  }\n\n  toggleLeg(legId: string): void {\n    if (!this.availableIds().has(legId)) return;\n    this.selectedLegIds.update(ids => (ids.includes(legId) ? ids.filter(i => i !== legId) : [...ids, legId]));\n  }\n\n  /** Legs -> edit: seed each selected leg with its current date / airports. */\n  goToEdit(): void {\n    if (!this.canContinue()) return;\n    if (this.service() === 'change_date') {\n      this.dateEdits.update(edits => {\n        const next = { ...edits };\n        for (const l of this.selectedLegs()) next[l.legId] ??= l.departure.slice(0, 10);\n        return next;\n      });\n    } else {\n      this.routeEdits.update(edits => {\n        const next = { ...edits };\n        for (const l of this.selectedLegs()) {\n          next[l.legId] ??= { origin: originAirport(l), destination: destinationAirport(l) };\n        }\n        return next;\n      });\n    }\n    this.step.set('edit');\n  }\n\n  goTo(step: ReissueStep): void {\n    this.step.set(step);\n  }\n\n  back(): void {\n    const previous: Record<ReissueStep, ReissueStep> = {\n      service: 'service',\n      legs: 'service',\n      edit: this.legsStepSkipped() ? 'service' : 'legs',\n      'upgrade-legs': 'service',\n      upgrade: 'service', // the upgrade store overrides this when the leg step was shown\n      confirm: 'upgrade',\n    };\n    this.step.update(s => previous[s]);\n  }\n\n  setDate(legId: string, date: string): void {\n    this.dateEdits.update(edits => ({ ...edits, [legId]: date }));\n  }\n\n  setAirport(legId: string, side: AirportSide, airport: ReissueAirport | null): void {\n    if (!airport) return;\n    const current = this.routeRows().find(r => r.leg.legId === legId);\n    if (!current) return;\n    this.routeEdits.update(edits => ({\n      ...edits,\n      [legId]: { origin: current.origin, destination: current.destination, [side]: airport },\n    }));\n  }\n\n  /** Swaps a leg's origin and destination (the arrow between the two pickers). */\n  swapAirports(legId: string): void {\n    const current = this.routeRows().find(r => r.leg.legId === legId);\n    if (!current) return;\n    this.routeEdits.update(edits => ({\n      ...edits,\n      [legId]: { origin: current.destination, destination: current.origin },\n    }));\n  }\n\n  searchAirports(term: string): void {\n    this.airportTerm$.next(term ?? '');\n  }\n\n  /** The web search URL for the current choices, or `null` when they are not valid yet. */\n  searchUrl(): string | null {\n    const ctx = this.ctx();\n    const service = this.service();\n    if (!ctx || !service || service === 'upgrade_class' || this.validationError()) return null;\n\n    const selection: ReissueSelection = {\n      service,\n      legs:\n        service === 'change_date'\n          ? this.dateRows().map(r => ({ legId: r.leg.legId, departDate: r.value }))\n          : this.routeRows().map(r => ({ legId: r.leg.legId, origin: r.origin, destination: r.destination })),\n    };\n    return buildReissueSearchUrl(this.config.webBaseUrl, ctx, selection, this.postBookingId());\n  }\n\n  // ── loading: post-booking -> availability -> upgrade options (once per dialog visit) ─────────\n\n  private loadFlow(): Observable<unknown> {\n    const ctx = this.ctx();\n    if (!ctx) {\n      this.error.set('This booking has no leg data to reissue.');\n      return EMPTY;\n    }\n    this.loading.set(true);\n    this.error.set(null);\n\n    return this.api.createPostBooking(ctx.bookingId).pipe(\n      switchMap(postBookingId => {\n        if (!postBookingId) return throwError(() => START_ERROR);\n        this.postBookingId.set(postBookingId);\n        return this.api.getAvailability(ctx.bookingId, postBookingId, ctx).pipe(\n          catchError(e => throwError(() => describeHttpError(AVAILABILITY_ERROR, e))),\n          tap(res => {\n            // A leg that already flew can never be changed, whatever availability says: treat it as offline.\n            const flown = new Set(ctx.legs.filter(isLegFlown).map(l => l.legId));\n            this.availableIds.set(\n              new Set((res?.data?.legs ?? []).filter(l => l.available && !flown.has(l.legId)).map(l => l.legId)),\n            );\n            this.allowSingleLegSelection.set(res?.data?.allowCustomerToSelectSingleLeg ?? true);\n            this.availabilityLoaded.set(true);\n          }),\n          switchMap(() => this.offersUpgrade(ctx.tripType, ctx.legs, postBookingId)),\n        );\n      }),\n      tap(options => {\n        this.upgradeOptions.set(options);\n        this.loading.set(false);\n      }),\n      catchError((e: unknown) => {\n        this.error.set(typeof e === 'string' ? e : describeHttpError(START_ERROR, e));\n        this.loading.set(false);\n        return EMPTY;\n      }),\n    );\n  }\n\n  /**\n   * The upgrade-class options (same rule as the web for listing \"Upgrade Class\"): skipped for a one-way whose\n   * only leg is offline; a failing call just yields `null` (option hidden) instead of blocking the dialog.\n   */\n  private offersUpgrade(\n    tripType: string,\n    legs: readonly ReissueLeg[],\n    postBookingId: string,\n  ): Observable<ReissueUpgradeOptionsResponse | null> {\n    const ctx = this.ctx();\n    const oneWayOffline = tripType === 'OneWay' && !this.availableIds().has(legs[0]?.legId);\n    if (!ctx || !legs.length || oneWayOffline) return of(null);\n    return this.api\n      .getUpgradeClassOptions(ctx.bookingId, postBookingId, ctx)\n      .pipe(catchError(() => of(null)));\n  }\n}\n"]}

package/esm2022/lib/components/reissue-dialog/steps/reissue-date-step/reissue-date-step.component.mjs

@@ -0,0 +1,45 @@
+import { ChangeDetectionStrategy, Component, input, output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SbdReissueDateStepComponent {
+    constructor() {
+        this.rows = input.required();
+        this.changed = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueDateStepComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: SbdReissueDateStepComponent, isStandalone: true, selector: "app-sbd-reissue-date-step", inputs: { rows: { classPropertyName: "rows", publicName: "rows", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { changed: "changed" }, host: { classAttribute: "sbd-rdate" }, ngImport: i0, template: `
+    @for (row of rows(); track row.leg.legId) {
+      <div class="sbd-rdate__card">
+        <div class="sbd-rdate__head">
+          <span class="sbd-rdate__name">{{ row.leg.originCode }} to {{ row.leg.destinationCode }}</span>
+          <span class="sbd-rdate__current">Currently {{ row.current }}</span>
+        </div>
+        <label class="sbd-rdate__field">
+          <span>New departure date</span>
+          <input type="date" class="sbd-rdate__input"
+            [value]="row.value" [min]="row.min" [attr.max]="row.max || null"
+            (input)="changed.emit({ legId: row.leg.legId, date: $any($event.target).value })" />
+        </label>
+      </div>
+    }
+  `, isInline: true, styles: [":host{display:flex;flex-direction:column;gap:12px}.sbd-rdate__card{border:1.5px solid #e2e8f0;border-radius:16px;background:#fff;transition:border-color .15s,box-shadow .15s;padding:16px;display:flex;flex-direction:column;gap:14px}.sbd-rdate__head{display:flex;flex-direction:column;gap:2px}.sbd-rdate__name{font-size:15px;font-weight:700;color:#1e2e4a}.sbd-rdate__current{font-size:13px;color:#64748b}.sbd-rdate__field{display:flex;flex-direction:column;gap:6px;min-width:0;font-size:12.5px;font-weight:600;color:#475569}.sbd-rdate__input{height:40px;padding:0 12px;border:1.5px solid #e2e8f0;border-radius:10px;background:#fff;font-size:13px;font-family:inherit;color:#1e2e4a}.sbd-rdate__input:focus{outline:none;border-color:var(--sbd-accent, #6d4aff)}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueDateStepComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-sbd-reissue-date-step', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    @for (row of rows(); track row.leg.legId) {
+      <div class="sbd-rdate__card">
+        <div class="sbd-rdate__head">
+          <span class="sbd-rdate__name">{{ row.leg.originCode }} to {{ row.leg.destinationCode }}</span>
+          <span class="sbd-rdate__current">Currently {{ row.current }}</span>
+        </div>
+        <label class="sbd-rdate__field">
+          <span>New departure date</span>
+          <input type="date" class="sbd-rdate__input"
+            [value]="row.value" [min]="row.min" [attr.max]="row.max || null"
+            (input)="changed.emit({ legId: row.leg.legId, date: $any($event.target).value })" />
+        </label>
+      </div>
+    }
+  `, host: { class: 'sbd-rdate' }, styles: [":host{display:flex;flex-direction:column;gap:12px}.sbd-rdate__card{border:1.5px solid #e2e8f0;border-radius:16px;background:#fff;transition:border-color .15s,box-shadow .15s;padding:16px;display:flex;flex-direction:column;gap:14px}.sbd-rdate__head{display:flex;flex-direction:column;gap:2px}.sbd-rdate__name{font-size:15px;font-weight:700;color:#1e2e4a}.sbd-rdate__current{font-size:13px;color:#64748b}.sbd-rdate__field{display:flex;flex-direction:column;gap:6px;min-width:0;font-size:12.5px;font-weight:600;color:#475569}.sbd-rdate__input{height:40px;padding:0 12px;border:1.5px solid #e2e8f0;border-radius:10px;background:#fff;font-size:13px;font-family:inherit;color:#1e2e4a}.sbd-rdate__input:focus{outline:none;border-color:var(--sbd-accent, #6d4aff)}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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