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

package/esm2022/lib/services/reissue.service.mjs

@@ -0,0 +1,142 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { SBD_CONFIG } from '../config/dashboard.config';
+import * as i0 from "@angular/core";
+/**
+ * Query params the web always sends on `create-post-booking` (`getEntrySourceDeviceBrand()`): where the flow started
+ * and on which device. Same defaults as the web; ask the backend which values BO should send.
+ */
+const POST_BOOKING_PARAMS = { entrySource: 'navigation bar', device: 'web' };
+/**
+ * Reissue APIs — the same endpoints the consumer web uses (the backend opens them for BO).
+ */
+export class SbdReissueService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.config = inject(SBD_CONFIG);
+        this.base = this.config.apiBase;
+    }
+    get headers() {
+        return { platform: this.config.platform };
+    }
+    /** `POST /v2/manage-booking/flight/create-post-booking/{bookingId}` -> `postBookingId`. */
+    createPostBooking(bookingId) {
+        return this.http
+            .post(`${this.base}/v2/manage-booking/flight/create-post-booking/${bookingId}`, null, // the web sends no body on this call
+        { headers: this.headers, params: POST_BOOKING_PARAMS })
+            .pipe(map(res => res?.data?.postBookingId ?? ''));
+    }
+    /** `GET /v3/manage-booking/flight/reissue/availability/{bookingId}/{postBookingId}` -> `data.legs[]`. */
+    getAvailability(bookingId, postBookingId, ctx) {
+        return this.http.get(`${this.base}/v3/manage-booking/flight/reissue/availability/${bookingId}/${postBookingId}`, { headers: this.headers });
+    }
+    /**
+     * `POST /v3/manage-booking/flight/reissue/upgrade-class/{bookingId}/{postBookingId}` — same call (and body) the
+     * web makes to decide whether the "Upgrade Class" option is shown. Returns the unwrapped `data`.
+     */
+    getUpgradeClassOptions(bookingId, postBookingId, ctx) {
+        const body = {
+            serviceName: 'change-flight-class',
+            legs: ctx.legs.map(l => ({
+                legId: l.legId,
+                legDepartureAirportCode: l.originCode,
+                legArrivalAirportCode: l.destinationCode,
+                legDepartureDate: l.departure,
+            })),
+        };
+        return this.http
+            .post(`${this.base}/v3/manage-booking/flight/reissue/upgrade-class/${bookingId}/${postBookingId}`, body, { headers: this.headers })
+            .pipe(map(res => (res?.data ?? res) ?? null));
+    }
+    /** Same rule as the web's `hasUpgradeOptions()`: at least one option in any section. */
+    hasUpgradeOptions(data) {
+        if (!data)
+            return false;
+        if (data.fareOptionScope === 'leg')
+            return (data.legs ?? []).some(l => (l.options?.length ?? 0) > 0);
+        return (data.options?.length ?? 0) > 0;
+    }
+    /**
+     * Airport picker for Change Route. Same typeahead endpoint the web and the backoffice already use
+     * (`StaticDataService.getAirports`) — no extra backend work needed. Response: `data[].items[].items[]`.
+     * An empty term makes no request (the dialog lists the booking's own airports meanwhile).
+     */
+    searchAirports(term) {
+        const q = term.trim();
+        if (!q)
+            return of([]);
+        return this.http
+            .get(`${this.base}/v1/typeahead-search-service/suggestion/suggest/flights`, { params: { q }, headers: this.headers })
+            .pipe(map(res => {
+            const out = [];
+            for (const group of res?.data ?? []) {
+                for (const item of group.items ?? []) {
+                    if (item.items)
+                        out.push(...item.items);
+                }
+            }
+            return out.map(a => ({
+                id: a.id,
+                name: a.name,
+                city_name: a.city_name,
+                country_name: a.country_name,
+                type: a.type === 'airport' ? 'airport' : 'city',
+            }));
+        }), catchError(() => of([])));
+    }
+    // ── Upgrade Class ──────────────────────────────────────────────────────────
+    /**
+     * `POST /v3/manage-booking/flight/reissue/choose-flight/{bookingId}/{postBookingId}` — prices the chosen upgrade
+     * option. Same endpoint/body the web uses; response `data` carries `itineraryAvailable`, `priceChanged`, `price`, `currency`.
+     */
+    chooseFlight(bookingId, postBookingId, body) {
+        return this.http
+            .post(`${this.base}/v3/manage-booking/flight/reissue/choose-flight/${bookingId}/${postBookingId}`, body, { headers: this.headers })
+            .pipe(map(res => res?.data ?? {}));
+    }
+    /** `POST /v2/manage-booking/flight/book-now` — places a zero-total reissue (no payment needed). */
+    bookNow(postBookingId) {
+        return this.http.post(`${this.base}/v2/manage-booking/flight/book-now`, { postBookingId }, { headers: this.headers });
+    }
+    /**
+     * Payment link of a reissue with an amount to pay. There is no separate API: the backend puts the link in the
+     * cart of the post-booking (`GET /v2/manage-booking/flight/cart/{postBookingId}`, the call the web checkout reads).
+     * The name of the field is not final yet: the first of the names below that exists is used, and the call fails
+     * with a clear message when the cart has none.
+     */
+    getPaymentLink(postBookingId, amount = 0, currency = '') {
+        return this.http
+            .get(`${this.base}/v2/manage-booking/flight/cart/${postBookingId}`, {
+            headers: this.headers,
+        })
+            .pipe(map(res => {
+            const cart = res?.data ?? {};
+            let url = cart['paymentLink'] ?? cart['link'] ?? cart['payment']?.link ?? cart['payment']?.paymentLink ?? cart['payment']?.url;
+            if (!url)
+                throw new Error('The cart has no payment link yet.');
+            // The cart returns only a path ("/<paymentId>"): the customer page base comes from the host config.
+            if (!/^https?:\/\//i.test(url)) {
+                const linkBase = this.config.paymentLinkBase?.replace(/\/+$/, '');
+                if (!linkBase) {
+                    throw new Error(`The cart returned a relative link (${url}) and no paymentLinkBase is configured.`);
+                }
+                url = `${linkBase}${url.startsWith('/') ? '' : '/'}${url}`;
+            }
+            return {
+                url,
+                amount: cart['payment']?.amount ?? amount,
+                currency: cart['payment']?.currency ?? currency,
+                expiresAt: cart['payment']?.expiryDate ?? cart['expiryDate'],
+            };
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdReissueService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reissue.service.js","sourceRoot":"","sources":["../../../../../projects/smart-booking-dashboard/src/lib/services/reissue.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, of } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport { SBD_CONFIG } from '../config/dashboard.config';\nimport {\n  ReissueAirport,\n  ReissueAvailabilityResponse,\n  ReissueBookingContext,\n  ReissueChooseFlightRequest,\n  ReissueChooseFlightResponse,\n  ReissuePaymentLink,\n  ReissueUpgradeOptionsResponse,\n} from '../models/reissue.types';\n\n/**\n * Query params the web always sends on `create-post-booking` (`getEntrySourceDeviceBrand()`): where the flow started\n * and on which device. Same defaults as the web; ask the backend which values BO should send.\n */\nconst POST_BOOKING_PARAMS = { entrySource: 'navigation bar', device: 'web' };\n\n/**\n * Reissue APIs — the same endpoints the consumer web uses (the backend opens them for BO).\n */\n@Injectable({ providedIn: 'root' })\nexport class SbdReissueService {\n  private http = inject(HttpClient);\n  private config = inject(SBD_CONFIG);\n  private base = this.config.apiBase;\n\n  private get headers(): Record<string, string> {\n    return { platform: this.config.platform };\n  }\n\n  /** `POST /v2/manage-booking/flight/create-post-booking/{bookingId}` -> `postBookingId`. */\n  createPostBooking(bookingId: string): Observable<string> {\n    return this.http\n      .post<{ data?: { postBookingId?: string } }>(\n        `${this.base}/v2/manage-booking/flight/create-post-booking/${bookingId}`,\n        null, // the web sends no body on this call\n        { headers: this.headers, params: POST_BOOKING_PARAMS },\n      )\n      .pipe(map(res => res?.data?.postBookingId ?? ''));\n  }\n\n  /** `GET /v3/manage-booking/flight/reissue/availability/{bookingId}/{postBookingId}` -> `data.legs[]`. */\n  getAvailability(\n    bookingId: string,\n    postBookingId: string,\n    ctx?: ReissueBookingContext,\n  ): Observable<ReissueAvailabilityResponse> {\n    return this.http.get<ReissueAvailabilityResponse>(\n      `${this.base}/v3/manage-booking/flight/reissue/availability/${bookingId}/${postBookingId}`,\n      { headers: this.headers },\n    );\n  }\n\n  /**\n   * `POST /v3/manage-booking/flight/reissue/upgrade-class/{bookingId}/{postBookingId}` — same call (and body) the\n   * web makes to decide whether the \"Upgrade Class\" option is shown. Returns the unwrapped `data`.\n   */\n  getUpgradeClassOptions(\n    bookingId: string,\n    postBookingId: string,\n    ctx: ReissueBookingContext,\n  ): Observable<ReissueUpgradeOptionsResponse | null> {\n    const body = {\n      serviceName: 'change-flight-class',\n      legs: ctx.legs.map(l => ({\n        legId: l.legId,\n        legDepartureAirportCode: l.originCode,\n        legArrivalAirportCode: l.destinationCode,\n        legDepartureDate: l.departure,\n      })),\n    };\n    return this.http\n      .post<{ data?: ReissueUpgradeOptionsResponse }>(\n        `${this.base}/v3/manage-booking/flight/reissue/upgrade-class/${bookingId}/${postBookingId}`,\n        body,\n        { headers: this.headers },\n      )\n      .pipe(map(res => (res?.data ?? (res as ReissueUpgradeOptionsResponse)) ?? null));\n  }\n\n  /** Same rule as the web's `hasUpgradeOptions()`: at least one option in any section. */\n  hasUpgradeOptions(data: ReissueUpgradeOptionsResponse | null): boolean {\n    if (!data) return false;\n    if (data.fareOptionScope === 'leg') return (data.legs ?? []).some(l => (l.options?.length ?? 0) > 0);\n    return (data.options?.length ?? 0) > 0;\n  }\n\n  /**\n   * Airport picker for Change Route. Same typeahead endpoint the web and the backoffice already use\n   * (`StaticDataService.getAirports`) — no extra backend work needed. Response: `data[].items[].items[]`.\n   * An empty term makes no request (the dialog lists the booking's own airports meanwhile).\n   */\n  searchAirports(term: string): Observable<ReissueAirport[]> {\n    const q = term.trim();\n    if (!q) return of([]);\n\n    return this.http\n      .get<{ data?: { items?: { items?: ReissueAirport[] }[] }[] }>(\n        `${this.base}/v1/typeahead-search-service/suggestion/suggest/flights`,\n        { params: { q }, headers: this.headers },\n      )\n      .pipe(\n        map(res => {\n          const out: ReissueAirport[] = [];\n          for (const group of res?.data ?? []) {\n            for (const item of group.items ?? []) {\n              if (item.items) out.push(...item.items);\n            }\n          }\n          return out.map(a => ({\n            id: a.id,\n            name: a.name,\n            city_name: a.city_name,\n            country_name: a.country_name,\n            type: a.type === 'airport' ? ('airport' as const) : ('city' as const),\n          }));\n        }),\n        catchError(() => of([] as ReissueAirport[])),\n      );\n  }\n\n  // ── Upgrade Class ──────────────────────────────────────────────────────────\n\n  /**\n   * `POST /v3/manage-booking/flight/reissue/choose-flight/{bookingId}/{postBookingId}` — prices the chosen upgrade\n   * option. Same endpoint/body the web uses; response `data` carries `itineraryAvailable`, `priceChanged`, `price`, `currency`.\n   */\n  chooseFlight(\n    bookingId: string,\n    postBookingId: string,\n    body: ReissueChooseFlightRequest,\n  ): Observable<ReissueChooseFlightResponse> {\n    return this.http\n      .post<{ data?: ReissueChooseFlightResponse }>(\n        `${this.base}/v3/manage-booking/flight/reissue/choose-flight/${bookingId}/${postBookingId}`,\n        body,\n        { headers: this.headers },\n      )\n      .pipe(map(res => res?.data ?? {}));\n  }\n\n  /** `POST /v2/manage-booking/flight/book-now` — places a zero-total reissue (no payment needed). */\n  bookNow(postBookingId: string): Observable<unknown> {\n    return this.http.post(`${this.base}/v2/manage-booking/flight/book-now`, { postBookingId }, { headers: this.headers });\n  }\n\n  /**\n   * Payment link of a reissue with an amount to pay. There is no separate API: the backend puts the link in the\n   * cart of the post-booking (`GET /v2/manage-booking/flight/cart/{postBookingId}`, the call the web checkout reads).\n   * The name of the field is not final yet: the first of the names below that exists is used, and the call fails\n   * with a clear message when the cart has none.\n   */\n  getPaymentLink(postBookingId: string, amount = 0, currency = ''): Observable<ReissuePaymentLink> {\n    return this.http\n      .get<{ data?: Record<string, any> }>(`${this.base}/v2/manage-booking/flight/cart/${postBookingId}`, {\n        headers: this.headers,\n      })\n      .pipe(\n        map(res => {\n          const cart = res?.data ?? {};\n          let url: string | undefined =\n            cart['paymentLink'] ?? cart['link'] ?? cart['payment']?.link ?? cart['payment']?.paymentLink ?? cart['payment']?.url;\n          if (!url) throw new Error('The cart has no payment link yet.');\n          // The cart returns only a path (\"/<paymentId>\"): the customer page base comes from the host config.\n          if (!/^https?:\\/\\//i.test(url)) {\n            const linkBase = this.config.paymentLinkBase?.replace(/\\/+$/, '');\n            if (!linkBase) {\n              throw new Error(`The cart returned a relative link (${url}) and no paymentLinkBase is configured.`);\n            }\n            url = `${linkBase}${url.startsWith('/') ? '' : '/'}${url}`;\n          }\n          return {\n            url,\n            amount: cart['payment']?.amount ?? amount,\n            currency: cart['payment']?.currency ?? currency,\n            expiresAt: cart['payment']?.expiryDate ?? cart['expiryDate'],\n          };\n        }),\n      );\n  }\n}\n"]}

package/esm2022/lib/services/toast.service.mjs

@@ -1,14 +1,22 @@
-import { Injectable, inject } from '@angular/core';
+import { Injectable, InjectionToken, inject } from '@angular/core';
 import { ToastrService } from 'ngx-toastr';
 import * as i0 from "@angular/core";
+export const SBD_TOAST_HANDLER = new InjectionToken('SBD_TOAST_HANDLER');
 export class SbdToastService {
     constructor() {
-        this.toastr = inject(ToastrService);
+        // The host's handler wins; ngx-toastr is the fallback and is optional, so a host that never configured it still works.
+        this.handler = inject(SBD_TOAST_HANDLER, { optional: true }) ?? inject(ToastrService, { optional: true });
+    }
+    success(msg) { this.show('success', msg); }
+    error(msg) { this.show('error', msg); }
+    info(msg) { this.show('info', msg); }
+    warning(msg) { this.show('warning', msg); }
+    show(kind, msg) {
+        if (this.handler)
+            this.handler[kind](msg);
+        else
+            console.warn(`[smart-booking-dashboard] ${kind}: ${msg}`);
     }
-    success(msg) { this.toastr.success(msg); }
-    error(msg) { this.toastr.error(msg); }
-    info(msg) { this.toastr.info(msg); }
-    warning(msg) { this.toastr.warning(msg); }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SbdToastService, providedIn: 'root' }); }
 }
@@ -16,4 +24,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3Quc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkL3NyYy9saWIvc2VydmljZXMvdG9hc3Quc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFDOztBQUczQyxNQUFNLE9BQU8sZUFBZTtJQUQ1QjtRQUVVLFdBQU0sR0FBRyxNQUFNLENBQUMsYUFBYSxDQUFDLENBQUM7S0FNeEM7SUFKQyxPQUFPLENBQUMsR0FBVyxJQUFVLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN4RCxLQUFLLENBQUMsR0FBVyxJQUFZLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN0RCxJQUFJLENBQUMsR0FBVyxJQUFhLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNyRCxPQUFPLENBQUMsR0FBVyxJQUFVLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQzsrR0FON0MsZUFBZTttSEFBZixlQUFlLGNBREYsTUFBTTs7NEZBQ25CLGVBQWU7a0JBRDNCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUb2FzdHJTZXJ2aWNlIH0gZnJvbSAnbmd4LXRvYXN0cic7XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgU2JkVG9hc3RTZXJ2aWNlIHtcbiAgcHJpdmF0ZSB0b2FzdHIgPSBpbmplY3QoVG9hc3RyU2VydmljZSk7XG5cbiAgc3VjY2Vzcyhtc2c6IHN0cmluZyk6IHZvaWQgeyB0aGlzLnRvYXN0ci5zdWNjZXNzKG1zZyk7IH1cbiAgZXJyb3IobXNnOiBzdHJpbmcpOiB2b2lkICAgeyB0aGlzLnRvYXN0ci5lcnJvcihtc2cpOyB9XG4gIGluZm8obXNnOiBzdHJpbmcpOiB2b2lkICAgIHsgdGhpcy50b2FzdHIuaW5mbyhtc2cpOyB9XG4gIHdhcm5pbmcobXNnOiBzdHJpbmcpOiB2b2lkIHsgdGhpcy50b2FzdHIud2FybmluZyhtc2cpOyB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3Quc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkL3NyYy9saWIvc2VydmljZXMvdG9hc3Quc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQzs7QUFhM0MsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxjQUFjLENBQWtCLG1CQUFtQixDQUFDLENBQUM7QUFHMUYsTUFBTSxPQUFPLGVBQWU7SUFENUI7UUFFRSx1SEFBdUg7UUFDL0csWUFBTyxHQUNiLE1BQU0sQ0FBQyxpQkFBaUIsRUFBRSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxhQUFhLEVBQUUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztLQVc5RjtJQVRDLE9BQU8sQ0FBQyxHQUFXLElBQVUsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3pELEtBQUssQ0FBQyxHQUFXLElBQVksSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3ZELElBQUksQ0FBQyxHQUFXLElBQWEsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3RELE9BQU8sQ0FBQyxHQUFXLElBQVUsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRWpELElBQUksQ0FBQyxJQUEyQixFQUFFLEdBQVc7UUFDbkQsSUFBSSxJQUFJLENBQUMsT0FBTztZQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUM7O1lBQ3JDLE9BQU8sQ0FBQyxJQUFJLENBQUMsNkJBQTZCLElBQUksS0FBSyxHQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7K0dBYlUsZUFBZTttSEFBZixlQUFlLGNBREYsTUFBTTs7NEZBQ25CLGVBQWU7a0JBRDNCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVG9hc3RyU2VydmljZSB9IGZyb20gJ25neC10b2FzdHInO1xuXG4vKipcbiAqIEhvdyB0aGUgZGFzaGJvYXJkIHNob3dzIG1lc3NhZ2VzLiBUaGUgYmFja29mZmljZSB1c2VzIG5neC10b2FzdHIgKHRoZSBkZWZhdWx0KTsgYSBob3N0IHRoYXQgaGFzIGl0cyBvd24gdG9hc3RcbiAqIHN5c3RlbSAoZS5nLiBIZWxpeCB3aXRoIFByaW1lTkcncyBgTWVzc2FnZVNlcnZpY2VgKSBwcm92aWRlcyB0aGlzIHRva2VuIGFuZCB0aGUgZGFzaGJvYXJkIHVzZXMgaXQgaW5zdGVhZC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTYmRUb2FzdEhhbmRsZXIge1xuICBzdWNjZXNzKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGVycm9yKG1lc3NhZ2U6IHN0cmluZyk6IHZvaWQ7XG4gIGluZm8obWVzc2FnZTogc3RyaW5nKTogdm9pZDtcbiAgd2FybmluZyhtZXNzYWdlOiBzdHJpbmcpOiB2b2lkO1xufVxuXG5leHBvcnQgY29uc3QgU0JEX1RPQVNUX0hBTkRMRVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48U2JkVG9hc3RIYW5kbGVyPignU0JEX1RPQVNUX0hBTkRMRVInKTtcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBTYmRUb2FzdFNlcnZpY2Uge1xuICAvLyBUaGUgaG9zdCdzIGhhbmRsZXIgd2luczsgbmd4LXRvYXN0ciBpcyB0aGUgZmFsbGJhY2sgYW5kIGlzIG9wdGlvbmFsLCBzbyBhIGhvc3QgdGhhdCBuZXZlciBjb25maWd1cmVkIGl0IHN0aWxsIHdvcmtzLlxuICBwcml2YXRlIGhhbmRsZXI6IFNiZFRvYXN0SGFuZGxlciB8IG51bGwgPVxuICAgIGluamVjdChTQkRfVE9BU1RfSEFORExFUiwgeyBvcHRpb25hbDogdHJ1ZSB9KSA/PyBpbmplY3QoVG9hc3RyU2VydmljZSwgeyBvcHRpb25hbDogdHJ1ZSB9KTtcblxuICBzdWNjZXNzKG1zZzogc3RyaW5nKTogdm9pZCB7IHRoaXMuc2hvdygnc3VjY2VzcycsIG1zZyk7IH1cbiAgZXJyb3IobXNnOiBzdHJpbmcpOiB2b2lkICAgeyB0aGlzLnNob3coJ2Vycm9yJywgbXNnKTsgfVxuICBpbmZvKG1zZzogc3RyaW5nKTogdm9pZCAgICB7IHRoaXMuc2hvdygnaW5mbycsIG1zZyk7IH1cbiAgd2FybmluZyhtc2c6IHN0cmluZyk6IHZvaWQgeyB0aGlzLnNob3coJ3dhcm5pbmcnLCBtc2cpOyB9XG5cbiAgcHJpdmF0ZSBzaG93KGtpbmQ6IGtleW9mIFNiZFRvYXN0SGFuZGxlciwgbXNnOiBzdHJpbmcpOiB2b2lkIHtcbiAgICBpZiAodGhpcy5oYW5kbGVyKSB0aGlzLmhhbmRsZXJba2luZF0obXNnKTtcbiAgICBlbHNlIGNvbnNvbGUud2FybihgW3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkXSAke2tpbmR9OiAke21zZ31gKTtcbiAgfVxufVxuIl19

package/esm2022/lib/utils/reissue-format.mjs

@@ -0,0 +1,64 @@
+/** Today as `YYYY-MM-DD` in the agent's timezone (what `<input type="date">` compares against). */
+export function todayIso() {
+    return new Date().toLocaleDateString('en-CA');
+}
+export function formatReissueDate(value) {
+    if (!value)
+        return '—';
+    const date = new Date(value);
+    return Number.isNaN(date.getTime())
+        ? value
+        : date.toLocaleDateString('en-GB', { day: '2-digit', month: 'short', year: 'numeric' });
+}
+/**
+ * Expiry of the payment link as epoch ms. The backend sends `YYYY-MM-DD HH:mm:ss` with no timezone, read as UTC (to
+ * be confirmed with the backend); a value that carries `Z` or an offset is read as it is. `null` when missing/invalid.
+ */
+export function parseLinkExpiry(value) {
+    if (!value)
+        return null;
+    const hasZone = /(Z|[+-]\d{2}:?\d{2})$/i.test(value.trim());
+    const ms = Date.parse(hasZone ? value : `${value.trim().replace(' ', 'T')}Z`);
+    return Number.isNaN(ms) ? null : ms;
+}
+/** `mm:ss` (or `h:mm:ss` from one hour up) for a countdown. */
+export function formatCountdown(ms) {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = total % 60;
+    const pad = (n) => String(n).padStart(2, '0');
+    return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${pad(m)}:${pad(s)}`;
+}
+export function legTitle(leg) {
+    return `${leg.direction || 'Leg'} · ${leg.originCode} → ${leg.destinationCode}`;
+}
+export function airportOf(id, name, city, country) {
+    return { id, name: name || city || id, city_name: city || id, country_name: country, type: 'airport' };
+}
+export const originAirport = (l) => airportOf(l.originCode, l.originName, l.originCityName, l.originCountryName);
+export const destinationAirport = (l) => airportOf(l.destinationCode, l.destinationName, l.destinationCityName, l.destinationCountryName);
+export const compareAirports = (a, b) => a?.id === b?.id;
+export function formatMoney(amount, currency) {
+    return `${amount.toLocaleString('en-US', { maximumFractionDigits: 2 })} ${currency}`.trim();
+}
+/** `21 Oct` — same short date the cancel dialog shows on a leg card. */
+export function formatShortDate(value) {
+    if (!value)
+        return '—';
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? value : date.toLocaleDateString('en-GB', { day: '2-digit', month: 'short' });
+}
+/** `01:55` straight from the `YYYY-MM-DDTHH:mm:ss` string (no timezone conversion). */
+export function formatTime(value) {
+    return value && value.length >= 16 && value[10] === 'T' ? value.slice(11, 16) : '—';
+}
+/**
+ * The leg already departed. The booking gives no timezone for `LegDepartureDateTime` (airport local time), so this
+ * compares with the agent's clock: it can be off by a few hours on the day of the flight, never by a day.
+ */
+export function isLegFlown(leg) {
+    const time = leg.departure ? Date.parse(leg.departure) : NaN;
+    return !Number.isNaN(time) && time < Date.now();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reissue-format.js","sourceRoot":"","sources":["../../../../../projects/smart-booking-dashboard/src/lib/utils/reissue-format.ts"],"names":[],"mappings":"AAEA,mGAAmG;AACnG,MAAM,UAAU,QAAQ;IACtB,OAAO,IAAI,IAAI,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,IAAI,CAAC,KAAK;QAAE,OAAO,GAAG,CAAC;IACvB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACjC,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;AAC5F,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,KAAqB;IACnD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,MAAM,OAAO,GAAG,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5D,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9E,OAAO,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;AACtC,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,eAAe,CAAC,EAAU;IACxC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;IACjD,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IACnC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC1C,MAAM,CAAC,GAAG,KAAK,GAAG,EAAE,CAAC;IACrB,MAAM,GAAG,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACtD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAe;IACtC,OAAO,GAAG,GAAG,CAAC,SAAS,IAAI,KAAK,MAAM,GAAG,CAAC,UAAU,MAAM,GAAG,CAAC,eAAe,EAAE,CAAC;AAClF,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,EAAU,EAAE,IAAY,EAAE,IAAY,EAAE,OAAe;IAC/E,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;AACzG,CAAC;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAa,EAAkB,EAAE,CAC7D,SAAS,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAC;AAE/E,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAa,EAAkB,EAAE,CAClE,SAAS,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,mBAAmB,EAAE,CAAC,CAAC,sBAAsB,CAAC,CAAC;AAEnG,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAiB,EAAE,CAAiB,EAAW,EAAE,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC;AAElG,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,QAAgB;IAC1D,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,EAAE,qBAAqB,EAAE,CAAC,EAAE,CAAC,IAAI,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;AAC9F,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,eAAe,CAAC,KAAa;IAC3C,IAAI,CAAC,KAAK;QAAE,OAAO,GAAG,CAAC;IACvB,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;AACrH,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,KAAK,IAAI,KAAK,CAAC,MAAM,IAAI,EAAE,IAAI,KAAK,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AACtF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,GAA0B;IACnD,MAAM,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAC7D,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;AAClD,CAAC","sourcesContent":["import { ReissueAirport, ReissueLeg } from '../models/reissue.types';\n\n/** Today as `YYYY-MM-DD` in the agent's timezone (what `<input type=\"date\">` compares against). */\nexport function todayIso(): string {\n  return new Date().toLocaleDateString('en-CA');\n}\n\nexport function formatReissueDate(value: string): string {\n  if (!value) return '—';\n  const date = new Date(value);\n  return Number.isNaN(date.getTime())\n    ? value\n    : date.toLocaleDateString('en-GB', { day: '2-digit', month: 'short', year: 'numeric' });\n}\n\n/**\n * Expiry of the payment link as epoch ms. The backend sends `YYYY-MM-DD HH:mm:ss` with no timezone, read as UTC (to\n * be confirmed with the backend); a value that carries `Z` or an offset is read as it is. `null` when missing/invalid.\n */\nexport function parseLinkExpiry(value?: string | null): number | null {\n  if (!value) return null;\n  const hasZone = /(Z|[+-]\\d{2}:?\\d{2})$/i.test(value.trim());\n  const ms = Date.parse(hasZone ? value : `${value.trim().replace(' ', 'T')}Z`);\n  return Number.isNaN(ms) ? null : ms;\n}\n\n/** `mm:ss` (or `h:mm:ss` from one hour up) for a countdown. */\nexport function formatCountdown(ms: number): string {\n  const total = Math.max(0, Math.floor(ms / 1000));\n  const h = Math.floor(total / 3600);\n  const m = Math.floor((total % 3600) / 60);\n  const s = total % 60;\n  const pad = (n: number) => String(n).padStart(2, '0');\n  return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${pad(m)}:${pad(s)}`;\n}\n\nexport function legTitle(leg: ReissueLeg): string {\n  return `${leg.direction || 'Leg'} · ${leg.originCode} → ${leg.destinationCode}`;\n}\n\nexport function airportOf(id: string, name: string, city: string, country: string): ReissueAirport {\n  return { id, name: name || city || id, city_name: city || id, country_name: country, type: 'airport' };\n}\n\nexport const originAirport = (l: ReissueLeg): ReissueAirport =>\n  airportOf(l.originCode, l.originName, l.originCityName, l.originCountryName);\n\nexport const destinationAirport = (l: ReissueLeg): ReissueAirport =>\n  airportOf(l.destinationCode, l.destinationName, l.destinationCityName, l.destinationCountryName);\n\nexport const compareAirports = (a: ReissueAirport, b: ReissueAirport): boolean => a?.id === b?.id;\n\nexport function formatMoney(amount: number, currency: string): string {\n  return `${amount.toLocaleString('en-US', { maximumFractionDigits: 2 })} ${currency}`.trim();\n}\n\n/** `21 Oct` — same short date the cancel dialog shows on a leg card. */\nexport function formatShortDate(value: string): string {\n  if (!value) return '—';\n  const date = new Date(value);\n  return Number.isNaN(date.getTime()) ? value : date.toLocaleDateString('en-GB', { day: '2-digit', month: 'short' });\n}\n\n/** `01:55` straight from the `YYYY-MM-DDTHH:mm:ss` string (no timezone conversion). */\nexport function formatTime(value: string): string {\n  return value && value.length >= 16 && value[10] === 'T' ? value.slice(11, 16) : '—';\n}\n\n/**\n * The leg already departed. The booking gives no timezone for `LegDepartureDateTime` (airport local time), so this\n * compares with the agent's clock: it can be off by a few hours on the day of the flight, never by a day.\n */\nexport function isLegFlown(leg: { departure: string }): boolean {\n  const time = leg.departure ? Date.parse(leg.departure) : NaN;\n  return !Number.isNaN(time) && time < Date.now();\n}\n"]}