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

package/esm2022/lib/shared/services/webengage-tracking.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WebengageTrackingService {
+    addEvent(eventName, eventData) {
+        // Stub implementation - does nothing in library context
+        if (typeof eventName === 'string') {
+            console.log('WebengageTracking:', eventName, eventData);
+        }
+        else {
+            console.log('WebengageTracking:', eventName);
+        }
+    }
+    setUserAttribute(attributeName, attributeValue) {
+        console.log('WebengageTracking setUserAttribute:', attributeName, attributeValue);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebengageTrackingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebengageTrackingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebengageTrackingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+export function resolveMyTripsViewedEntrySourceFromQueryParams(params) {
+    return params?.source || 'unknown';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/store/selectors/currency.selectors.mjs

@@ -0,0 +1,9 @@
+import { createSelector } from '@ngrx/store';
+// Stub selector for getCurrentCurrency
+export const getCurrentCurrency = createSelector(() => ({}), () => ({
+    code: 'SAR',
+    name: 'Saudi Riyal',
+    symbol: 'SAR',
+    rate: 1
+}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVuY3kuc2VsZWN0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtYm9va2luZy1kYXNoYm9hcmQvc3JjL2xpYi9zaGFyZWQvc3RvcmUvc2VsZWN0b3JzL2N1cnJlbmN5LnNlbGVjdG9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRzdDLHVDQUF1QztBQUN2QyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxjQUFjLENBQzlDLEdBQUcsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQ1YsR0FBYyxFQUFFLENBQUMsQ0FBQztJQUNoQixJQUFJLEVBQUUsS0FBSztJQUNYLElBQUksRUFBRSxhQUFhO0lBQ25CLE1BQU0sRUFBRSxLQUFLO0lBQ2IsSUFBSSxFQUFFLENBQUM7Q0FDUixDQUFDLENBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNyZWF0ZVNlbGVjdG9yIH0gZnJvbSAnQG5ncngvc3RvcmUnO1xuaW1wb3J0IHsgSUN1cnJlbmN5IH0gZnJvbSAnLi4vLi4vbW9kZWxzJztcblxuLy8gU3R1YiBzZWxlY3RvciBmb3IgZ2V0Q3VycmVudEN1cnJlbmN5XG5leHBvcnQgY29uc3QgZ2V0Q3VycmVudEN1cnJlbmN5ID0gY3JlYXRlU2VsZWN0b3IoXG4gICgpID0+ICh7fSksXG4gICgpOiBJQ3VycmVuY3kgPT4gKHtcbiAgICBjb2RlOiAnU0FSJyxcbiAgICBuYW1lOiAnU2F1ZGkgUml5YWwnLFxuICAgIHN5bWJvbDogJ1NBUicsXG4gICAgcmF0ZTogMVxuICB9KVxuKTtcbiJdfQ==

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":"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","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"]}

package/esm2022/lib/utils/reissue-url.builder.mjs

@@ -0,0 +1,314 @@
+/**
+ * Port of the web's `FlightManageBookingService.navigateToOnlineBooking()`
+ * (almatar-consumer-apps) — builds the query params of
+ * `/flights/manage-booking/list`, where the web continues the reissue
+ * (search -> view-price -> choose-flight -> payment).
+ * Keep the param names/values identical to the web.
+ */
+export const REISSUE_WEB_PATH = '/flights/manage-booking/list/';
+/** Same strings as the web's `FlightManageBookingAsideTabEnum`. */
+const SERVICE_NAME = {
+    change_date: 'change-travel-date-time',
+    change_route: 'change-flight-route',
+};
+// ── date helpers ────────────────────────────────────────────────────────────
+/** `moment.utc(str).valueOf()` — strings without a timezone are read as UTC. */
+function utcMs(value) {
+    const hasTz = /[zZ]$|[+-]\d{2}:?\d{2}$/.test(value);
+    return new Date(hasTz ? value : `${value}Z`).getTime();
+}
+/** Web's `getAbsoluteDate(date)` -> `YYYY-MM-DD` of the date part. */
+function dateOnly(value) {
+    return value.slice(0, 10);
+}
+/** Web's `getAbsoluteDate(date, true)` -> UTC midnight of that calendar day. */
+function absoluteMs(value) {
+    const [y, m, d] = dateOnly(value).split('-').map(Number);
+    return Date.UTC(y, m - 1, d);
+}
+function capitalize(value) {
+    return value ? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase() : value;
+}
+// ── booking_info -> context ─────────────────────────────────────────────────
+function inferTripType(bi, legs) {
+    const explicit = bi?.IteneraryTripType;
+    if (explicit === 'OneWay' || explicit === 'RoundTrip' || explicit === 'MultiCity')
+        return explicit;
+    if (legs.length <= 1)
+        return 'OneWay';
+    if (legs.length === 2 && legs[1].direction === 'Return')
+        return 'RoundTrip';
+    return 'MultiCity';
+}
+function countPassengers(bi, type) {
+    const list = bi?.passenger_info?.passengers ?? [];
+    return list.filter(p => p?.type === type).length;
+}
+/**
+ * Normalizes the dashboard's `booking_info` (from `/v1/fcr/booking/information`)
+ * into what the URL builder needs. Reads defensively: any field missing in the
+ * BO response falls back to an empty value.
+ */
+export function buildReissueBookingContext(bookingData, bookingId) {
+    const bi = bookingData?.data?.booking_info;
+    const legsRaw = bi?.leg_info ?? [];
+    if (!legsRaw.length)
+        return null;
+    const airline = bi?.airline_info ?? [];
+    const legs = legsRaw.map((l, i) => {
+        const segs = airline[i]?.Segments ?? [];
+        const first = segs[0] ?? {};
+        const last = segs[segs.length - 1] ?? first;
+        // Some bookings come back with a sparse `leg_info` — fall back to the
+        // first/last segment (airline_info, then duration/terminal) for the route and times.
+        const durSegs = bi?.duration?.legs?.[i]?.Segments ?? [];
+        const termSegs = bi?.terminal?.[i]?.Segments ?? [];
+        const firstAny = { ...(termSegs[0] ?? {}), ...(durSegs[0] ?? {}), ...first };
+        const lastAny = {
+            ...(termSegs[termSegs.length - 1] ?? {}),
+            ...(durSegs[durSegs.length - 1] ?? {}),
+            ...last,
+        };
+        const originCode = l.LegDepartureAirportCode ?? firstAny.DepartureAirportCode ?? firstAny.SegmentDepartureAirportCode ?? '';
+        const destinationCode = l.LegArrivalAirportCode ?? lastAny.ArrivalAirportCode ?? lastAny.SegmentArrivalAirportCode ?? '';
+        return {
+            // No id in the response -> a positional placeholder so the dialog still works.
+            legId: l.LegID ?? l.legId ?? l.LegId ?? `leg-${i}`,
+            direction: l.LegDirectionality ?? '',
+            originCode,
+            originName: l.LegDepartureAirportName ?? firstAny.DepartureAirportName ?? '',
+            originCityName: l.LegDepartureCityName ?? firstAny.SegmentDepartureCityName ?? firstAny.DepartureAirportName ?? originCode,
+            originCountryName: l.LegDepartureCountryName ?? firstAny.SegmentDepartureCountryName ?? '',
+            destinationCode,
+            destinationName: l.LegArrivalAirportName ?? lastAny.ArrivalAirportName ?? '',
+            destinationCityName: l.LegArrivalCityName ?? lastAny.SegmentArrivalCityName ?? lastAny.ArrivalAirportName ?? destinationCode,
+            destinationCountryName: l.LegArrivalCountryName ?? lastAny.SegmentArrivalCountryName ?? '',
+            departure: l.LegDepartureDateTime ?? firstAny.DepartureDateTime ?? firstAny.SegmentDepartureDateTime ?? firstAny.DepartureTime ?? '',
+            arrival: l.LegArrivalDateTime ?? lastAny.ArrivalDateTime ?? lastAny.SegmentArrivalDateTime ?? lastAny.ArrivalTime ?? '',
+            airline: (l.LegAirlinesNames ?? [])[0] ?? first.AirlineName ?? '',
+            stops: (l.Stops ?? []).length,
+            flightNo: first.AirlineCode ? `${first.AirlineCode}${first.FlightNumber ?? ''}` : '',
+        };
+    });
+    const firstLegRaw = legsRaw[0];
+    const firstSeg = airline[0]?.Segments?.[0] ?? {};
+    return {
+        bookingId: String(bookingId),
+        tripType: inferTripType(bi, legs),
+        legs,
+        adults: countPassengers(bi, 'ADT'),
+        children: countPassengers(bi, 'CNN'),
+        infants: countPassengers(bi, 'INF'),
+        // The BO response may carry no cabin at all (sparse bookings) — default so the web search still gets a class.
+        cabinName: firstLegRaw.LegCabins?.[0]?.Name ?? 'Economy',
+        cabinCode: firstLegRaw.LegCabins?.[0]?.Code ?? 'Y',
+        currency: bi?.currency ?? bi?.payment_status?.currency ?? '',
+        airlineCode: firstSeg.AirlineCode ?? '',
+        flightNumber: String(firstSeg.FlightNumber ?? ''),
+        airlineName: (firstLegRaw.LegAirlinesNames ?? [])[0] ?? firstSeg.AirlineName ?? '',
+        totalStops: (firstLegRaw.Stops ?? []).length,
+    };
+}
+// ── URL builder ─────────────────────────────────────────────────────────────
+function airportCityLabel(name, country, code) {
+    return `${name || code}${country ? ', ' + country : ''}(${code})`;
+}
+function otherLegOf(ctx, legId) {
+    const other = ctx.legs.find(l => l.legId !== legId);
+    return other
+        ? {
+            legId: other.legId,
+            departDateTime: other.departure,
+            destinationCode: other.destinationCode,
+            originCode: other.originCode,
+            isReturn: other.direction === 'Return',
+        }
+        : undefined;
+}
+export function buildReissueSearchParams(rawCtx, selection, postBookingId) {
+    // The BO booking information may carry no leg dates at all. Without an original date the
+    // web's `departure` / `return` / `updatingLegs` would be NaN, so fall back to the date the
+    // agent picked (or today) — only affects sparse bookings; real ones have `LegDepartureDateTime`.
+    const fallbackDate = `${selection.legs.find(c => c.departDate)?.departDate ?? new Date().toLocaleDateString('en-CA')}T00:00:00`;
+    const ctx = {
+        ...rawCtx,
+        legs: rawCtx.legs.map(l => (l.departure ? l : { ...l, departure: fallbackDate })),
+    };
+    const isDate = selection.service === 'change_date';
+    const leg0 = ctx.legs[0];
+    const changes = selection.legs;
+    const legOf = (c) => ctx.legs.find(l => l.legId === c.legId) ?? leg0;
+    // `config.legs` in the web.
+    const legsPayload = changes.map(c => {
+        const orig = legOf(c);
+        if (isDate) {
+            return {
+                legId: c.legId,
+                ...(ctx.tripType === 'MultiCity' ? { touched: true } : {}),
+                departDateTime: dateOnly(c.departDate ?? orig.departure),
+                destinationCode: orig.destinationCode,
+                originCode: orig.originCode,
+            };
+        }
+        return {
+            legId: c.legId,
+            originCode: c.origin?.id ?? orig.originCode,
+            originCityName: c.origin?.city_name || c.origin?.name || orig.originCityName,
+            destinationCode: c.destination?.id ?? orig.destinationCode,
+            destinationCityName: c.destination?.city_name || c.destination?.name || orig.destinationCityName,
+            departDateTime: orig.departure,
+        };
+    });
+    // `routeConfig` in the web.
+    const first = changes[0];
+    const routeOrigin = !isDate ? first?.origin : undefined;
+    const routeDest = !isDate ? first?.destination : undefined;
+    const routeDeparture = isDate ? `${dateOnly(changes[0].departDate ?? leg0.departure)}T00:00:00` : undefined;
+    const routeReturn = isDate && changes.length > 1
+        ? `${dateOnly(changes[1].departDate ?? ctx.legs[1]?.departure ?? '')}T00:00:00`
+        : undefined;
+    const origin = routeOrigin?.id ?? leg0.originCode;
+    const destination = routeDest?.id ?? leg0.destinationCode;
+    const className = ctx.cabinName.toUpperCase().includes('ECONOMY')
+        ? capitalize(ctx.cabinName.replace(/\s+/g, ''))
+        : ctx.cabinName;
+    const params = {
+        flightSearchId: ctx.bookingId,
+        category: 'flights',
+        id: `${ctx.airlineCode}-${ctx.flightNumber}`,
+        origin,
+        originCity: routeOrigin
+            ? routeOrigin.name || `${routeOrigin.city_name}, ${routeOrigin.country_name}`
+            : airportCityLabel(leg0.originName, leg0.originCountryName, leg0.originCode),
+        originCityName: routeOrigin?.city_name ?? leg0.originCityName,
+        originCountryName: routeOrigin?.country_name ?? leg0.originCountryName,
+        destinationCityName: routeDest?.city_name ?? leg0.destinationCityName,
+        destinationCity: routeDest
+            ? routeDest.name || `${routeDest.city_name}, ${routeDest.country_name}`
+            : airportCityLabel(leg0.destinationName, leg0.destinationCountryName, leg0.destinationCode),
+        destinationCountryName: routeDest?.country_name ?? leg0.destinationCountryName,
+        destination,
+        departureFlightAirlines: ctx.airlineName,
+        adult: ctx.adults,
+        child: ctx.children,
+        lapinfant: ctx.infants,
+        class: className,
+        className: ctx.cabinCode,
+        departure: utcMs(routeDeparture ?? leg0.departure),
+        infantonchair: 0,
+        originType: routeOrigin?.type ?? 'city',
+        destinationType: routeDest?.type ?? 'city',
+        isDirect: 'false',
+        serviceName: SERVICE_NAME[selection.service],
+        currency: ctx.currency,
+        classType: ctx.cabinCode,
+        connection: ctx.tripType,
+        directFlights: ctx.totalStops === 0,
+        flexibleDates: false,
+        legs: JSON.stringify(legsPayload),
+        // Lets the results page show an "UPDATING NOW" banner per changed leg.
+        updatingLegs: JSON.stringify(changes.map(c => {
+            const o = legOf(c);
+            return {
+                legId: o.legId,
+                direction: o.direction,
+                originCode: o.originCode,
+                destinationCode: o.destinationCode,
+                originCityName: o.originCityName,
+                destinationCityName: o.destinationCityName,
+                originalDeparture: utcMs(o.departure),
+            };
+        })),
+    };
+    if (ctx.tripType === 'RoundTrip') {
+        const secondLeg = ctx.legs[1];
+        params['return'] = routeReturn
+            ? utcMs(routeReturn)
+            : secondLeg
+                ? utcMs(secondLeg.departure) // the web parses this one in the customer's timezone; read as UTC here so it doesn't depend on the agent's timezone
+                : utcMs(String(legsPayload[0].departDateTime));
+        if (changes.length === 1) {
+            const other = otherLegOf(ctx, changes[0].legId);
+            if (isDate && other && !other.isReturn) {
+                params['departure'] = utcMs(other.departDateTime);
+                params['return'] = utcMs(String(legsPayload[0].departDateTime));
+            }
+            if (other)
+                params['extraLeg'] = JSON.stringify(other);
+        }
+    }
+    if (ctx.tripType === 'MultiCity') {
+        let cities;
+        if (isDate) {
+            const changedDate = new Map(changes.map(c => [c.legId, c.departDate]));
+            cities = ctx.legs.map(l => ({
+                departure: absoluteMs(changedDate.get(l.legId) || l.departure),
+                destination: l.destinationCode,
+                destinationType: l.destinationCode,
+                origin: l.originCode,
+                originType: l.originCode,
+                destinationCity: l.destinationCityName,
+                destinationCityName: l.destinationCityName,
+                destinationName: l.destinationCityName,
+                destinationCountryName: l.destinationCountryName,
+                originCity: l.originCityName,
+                originCityName: l.originCityName,
+                originName: l.originCityName,
+                originCountryName: l.originCountryName,
+            }));
+        }
+        else {
+            cities = changes.map(c => {
+                const o = legOf(c);
+                const from = c.origin;
+                const to = c.destination;
+                return {
+                    departure: utcMs(o.departure),
+                    destination: to?.id ?? o.destinationCode,
+                    destinationType: to?.type ?? o.destinationCode,
+                    origin: from?.id ?? o.originCode,
+                    originType: from?.id ?? o.originCode,
+                    destinationCity: to?.name ?? o.destinationCityName,
+                    destinationCityName: to?.name ?? o.destinationCityName,
+                    destinationName: to?.name ?? o.destinationCityName,
+                    destinationCountryName: to?.country_name ?? o.destinationCountryName,
+                    originCity: from?.name ?? o.originCityName,
+                    originCityName: from?.name ?? o.originCityName,
+                    originName: from?.name ?? o.originCityName,
+                    originCountryName: from?.country_name ?? o.originCountryName,
+                };
+            });
+        }
+        params['departure'] = cities[0].departure;
+        params['cities'] = JSON.stringify(cities);
+    }
+    params['bookingId'] = ctx.bookingId;
+    params['postBookingId'] = postBookingId;
+    return Object.fromEntries(Object.entries(params)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => [k, String(v)]));
+}
+export function buildReissueSearchUrl(webBaseUrl, ctx, selection, postBookingId) {
+    const qs = new URLSearchParams(buildReissueSearchParams(ctx, selection, postBookingId));
+    return `${webBaseUrl.replace(/\/+$/, '')}${REISSUE_WEB_PATH}?${qs.toString()}`;
+}
+/**
+ * Adds the host's auth parameters (for example its token) to the web link: in the query string, or in the `#fragment`
+ * (which browsers do not send to servers or in the Referer). Empty values are skipped.
+ */
+export function appendAuthParams(url, params, where = 'query') {
+    const entries = Object.entries(params ?? {}).filter(([, value]) => !!value);
+    if (!entries.length)
+        return url;
+    const target = new URL(url);
+    if (where === 'hash') {
+        const hash = new URLSearchParams(target.hash.replace(/^#/, ''));
+        entries.forEach(([name, value]) => hash.set(name, value));
+        target.hash = hash.toString();
+    }
+    else {
+        entries.forEach(([name, value]) => target.searchParams.set(name, value));
+    }
+    return target.toString();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reissue-url.builder.js","sourceRoot":"","sources":["../../../../../projects/smart-booking-dashboard/src/lib/utils/reissue-url.builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ReissueAirport,\n  ReissueBookingContext,\n  ReissueLeg,\n  ReissueLegChange,\n  ReissueSelection,\n  ReissueTripType,\n} from '../models/reissue.types';\n\n/**\n * Port of the web's `FlightManageBookingService.navigateToOnlineBooking()`\n * (almatar-consumer-apps) — builds the query params of\n * `/flights/manage-booking/list`, where the web continues the reissue\n * (search -> view-price -> choose-flight -> payment).\n * Keep the param names/values identical to the web.\n */\n\nexport const REISSUE_WEB_PATH = '/flights/manage-booking/list/';\n\n/** Same strings as the web's `FlightManageBookingAsideTabEnum`. */\nconst SERVICE_NAME = {\n  change_date: 'change-travel-date-time',\n  change_route: 'change-flight-route',\n} as const;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Raw = any;\n\n// ── date helpers ────────────────────────────────────────────────────────────\n\n/** `moment.utc(str).valueOf()` — strings without a timezone are read as UTC. */\nfunction utcMs(value: string): number {\n  const hasTz = /[zZ]$|[+-]\\d{2}:?\\d{2}$/.test(value);\n  return new Date(hasTz ? value : `${value}Z`).getTime();\n}\n\n/** Web's `getAbsoluteDate(date)` -> `YYYY-MM-DD` of the date part. */\nfunction dateOnly(value: string): string {\n  return value.slice(0, 10);\n}\n\n/** Web's `getAbsoluteDate(date, true)` -> UTC midnight of that calendar day. */\nfunction absoluteMs(value: string): number {\n  const [y, m, d] = dateOnly(value).split('-').map(Number);\n  return Date.UTC(y, m - 1, d);\n}\n\nfunction capitalize(value: string): string {\n  return value ? value.charAt(0).toUpperCase() + value.slice(1).toLowerCase() : value;\n}\n\n// ── booking_info -> context ─────────────────────────────────────────────────\n\nfunction inferTripType(bi: Raw, legs: ReissueLeg[]): ReissueTripType {\n  const explicit = bi?.IteneraryTripType;\n  if (explicit === 'OneWay' || explicit === 'RoundTrip' || explicit === 'MultiCity') return explicit;\n  if (legs.length <= 1) return 'OneWay';\n  if (legs.length === 2 && legs[1].direction === 'Return') return 'RoundTrip';\n  return 'MultiCity';\n}\n\nfunction countPassengers(bi: Raw, type: string): number {\n  const list: Raw[] = bi?.passenger_info?.passengers ?? [];\n  return list.filter(p => p?.type === type).length;\n}\n\n/**\n * Normalizes the dashboard's `booking_info` (from `/v1/fcr/booking/information`)\n * into what the URL builder needs. Reads defensively: any field missing in the\n * BO response falls back to an empty value.\n */\nexport function buildReissueBookingContext(bookingData: Raw, bookingId: string): ReissueBookingContext | null {\n  const bi = bookingData?.data?.booking_info;\n  const legsRaw: Raw[] = bi?.leg_info ?? [];\n  if (!legsRaw.length) return null;\n\n  const airline: Raw[] = bi?.airline_info ?? [];\n  const legs: ReissueLeg[] = legsRaw.map((l, i) => {\n    const segs: Raw[] = airline[i]?.Segments ?? [];\n    const first = segs[0] ?? {};\n    const last = segs[segs.length - 1] ?? first;\n    // Some bookings come back with a sparse `leg_info` — fall back to the\n    // first/last segment (airline_info, then duration/terminal) for the route and times.\n    const durSegs: Raw[] = bi?.duration?.legs?.[i]?.Segments ?? [];\n    const termSegs: Raw[] = bi?.terminal?.[i]?.Segments ?? [];\n    const firstAny: Raw = { ...(termSegs[0] ?? {}), ...(durSegs[0] ?? {}), ...first };\n    const lastAny: Raw = {\n      ...(termSegs[termSegs.length - 1] ?? {}),\n      ...(durSegs[durSegs.length - 1] ?? {}),\n      ...last,\n    };\n    const originCode: string = l.LegDepartureAirportCode ?? firstAny.DepartureAirportCode ?? firstAny.SegmentDepartureAirportCode ?? '';\n    const destinationCode: string = l.LegArrivalAirportCode ?? lastAny.ArrivalAirportCode ?? lastAny.SegmentArrivalAirportCode ?? '';\n    return {\n      // No id in the response -> a positional placeholder so the dialog still works.\n      legId: l.LegID ?? l.legId ?? l.LegId ?? `leg-${i}`,\n      direction: l.LegDirectionality ?? '',\n      originCode,\n      originName: l.LegDepartureAirportName ?? firstAny.DepartureAirportName ?? '',\n      originCityName: l.LegDepartureCityName ?? firstAny.SegmentDepartureCityName ?? firstAny.DepartureAirportName ?? originCode,\n      originCountryName: l.LegDepartureCountryName ?? firstAny.SegmentDepartureCountryName ?? '',\n      destinationCode,\n      destinationName: l.LegArrivalAirportName ?? lastAny.ArrivalAirportName ?? '',\n      destinationCityName: l.LegArrivalCityName ?? lastAny.SegmentArrivalCityName ?? lastAny.ArrivalAirportName ?? destinationCode,\n      destinationCountryName: l.LegArrivalCountryName ?? lastAny.SegmentArrivalCountryName ?? '',\n      departure:\n        l.LegDepartureDateTime ?? firstAny.DepartureDateTime ?? firstAny.SegmentDepartureDateTime ?? firstAny.DepartureTime ?? '',\n      arrival:\n        l.LegArrivalDateTime ?? lastAny.ArrivalDateTime ?? lastAny.SegmentArrivalDateTime ?? lastAny.ArrivalTime ?? '',\n      airline: (l.LegAirlinesNames ?? [])[0] ?? first.AirlineName ?? '',\n      stops: (l.Stops ?? []).length,\n      flightNo: first.AirlineCode ? `${first.AirlineCode}${first.FlightNumber ?? ''}` : '',\n    };\n  });\n\n  const firstLegRaw = legsRaw[0];\n  const firstSeg: Raw = airline[0]?.Segments?.[0] ?? {};\n  return {\n    bookingId: String(bookingId),\n    tripType: inferTripType(bi, legs),\n    legs,\n    adults: countPassengers(bi, 'ADT'),\n    children: countPassengers(bi, 'CNN'),\n    infants: countPassengers(bi, 'INF'),\n    // The BO response may carry no cabin at all (sparse bookings) — default so the web search still gets a class.\n    cabinName: firstLegRaw.LegCabins?.[0]?.Name ?? 'Economy',\n    cabinCode: firstLegRaw.LegCabins?.[0]?.Code ?? 'Y',\n    currency: bi?.currency ?? bi?.payment_status?.currency ?? '',\n    airlineCode: firstSeg.AirlineCode ?? '',\n    flightNumber: String(firstSeg.FlightNumber ?? ''),\n    airlineName: (firstLegRaw.LegAirlinesNames ?? [])[0] ?? firstSeg.AirlineName ?? '',\n    totalStops: (firstLegRaw.Stops ?? []).length,\n  };\n}\n\n// ── URL builder ─────────────────────────────────────────────────────────────\n\nfunction airportCityLabel(name: string, country: string, code: string): string {\n  return `${name || code}${country ? ', ' + country : ''}(${code})`;\n}\n\nfunction otherLegOf(ctx: ReissueBookingContext, legId: string) {\n  const other = ctx.legs.find(l => l.legId !== legId);\n  return other\n    ? {\n        legId: other.legId,\n        departDateTime: other.departure,\n        destinationCode: other.destinationCode,\n        originCode: other.originCode,\n        isReturn: other.direction === 'Return',\n      }\n    : undefined;\n}\n\nexport function buildReissueSearchParams(\n  rawCtx: ReissueBookingContext,\n  selection: ReissueSelection,\n  postBookingId: string,\n): Record<string, string> {\n  // The BO booking information may carry no leg dates at all. Without an original date the\n  // web's `departure` / `return` / `updatingLegs` would be NaN, so fall back to the date the\n  // agent picked (or today) — only affects sparse bookings; real ones have `LegDepartureDateTime`.\n  const fallbackDate = `${selection.legs.find(c => c.departDate)?.departDate ?? new Date().toLocaleDateString('en-CA')}T00:00:00`;\n  const ctx: ReissueBookingContext = {\n    ...rawCtx,\n    legs: rawCtx.legs.map(l => (l.departure ? l : { ...l, departure: fallbackDate })),\n  };\n  const isDate = selection.service === 'change_date';\n  const leg0 = ctx.legs[0];\n  const changes = selection.legs;\n  const legOf = (c: ReissueLegChange) => ctx.legs.find(l => l.legId === c.legId) ?? leg0;\n\n  // `config.legs` in the web.\n  const legsPayload = changes.map(c => {\n    const orig = legOf(c);\n    if (isDate) {\n      return {\n        legId: c.legId,\n        ...(ctx.tripType === 'MultiCity' ? { touched: true } : {}),\n        departDateTime: dateOnly(c.departDate ?? orig.departure),\n        destinationCode: orig.destinationCode,\n        originCode: orig.originCode,\n      };\n    }\n    return {\n      legId: c.legId,\n      originCode: c.origin?.id ?? orig.originCode,\n      originCityName: c.origin?.city_name || c.origin?.name || orig.originCityName,\n      destinationCode: c.destination?.id ?? orig.destinationCode,\n      destinationCityName: c.destination?.city_name || c.destination?.name || orig.destinationCityName,\n      departDateTime: orig.departure,\n    };\n  });\n\n  // `routeConfig` in the web.\n  const first = changes[0];\n  const routeOrigin: ReissueAirport | undefined = !isDate ? first?.origin : undefined;\n  const routeDest: ReissueAirport | undefined = !isDate ? first?.destination : undefined;\n  const routeDeparture = isDate ? `${dateOnly(changes[0].departDate ?? leg0.departure)}T00:00:00` : undefined;\n  const routeReturn =\n    isDate && changes.length > 1\n      ? `${dateOnly(changes[1].departDate ?? ctx.legs[1]?.departure ?? '')}T00:00:00`\n      : undefined;\n\n  const origin = routeOrigin?.id ?? leg0.originCode;\n  const destination = routeDest?.id ?? leg0.destinationCode;\n  const className = ctx.cabinName.toUpperCase().includes('ECONOMY')\n    ? capitalize(ctx.cabinName.replace(/\\s+/g, ''))\n    : ctx.cabinName;\n\n  const params: Record<string, unknown> = {\n    flightSearchId: ctx.bookingId,\n    category: 'flights',\n    id: `${ctx.airlineCode}-${ctx.flightNumber}`,\n    origin,\n    originCity: routeOrigin\n      ? routeOrigin.name || `${routeOrigin.city_name}, ${routeOrigin.country_name}`\n      : airportCityLabel(leg0.originName, leg0.originCountryName, leg0.originCode),\n    originCityName: routeOrigin?.city_name ?? leg0.originCityName,\n    originCountryName: routeOrigin?.country_name ?? leg0.originCountryName,\n    destinationCityName: routeDest?.city_name ?? leg0.destinationCityName,\n    destinationCity: routeDest\n      ? routeDest.name || `${routeDest.city_name}, ${routeDest.country_name}`\n      : airportCityLabel(leg0.destinationName, leg0.destinationCountryName, leg0.destinationCode),\n    destinationCountryName: routeDest?.country_name ?? leg0.destinationCountryName,\n    destination,\n    departureFlightAirlines: ctx.airlineName,\n    adult: ctx.adults,\n    child: ctx.children,\n    lapinfant: ctx.infants,\n    class: className,\n    className: ctx.cabinCode,\n    departure: utcMs(routeDeparture ?? leg0.departure),\n    infantonchair: 0,\n    originType: routeOrigin?.type ?? 'city',\n    destinationType: routeDest?.type ?? 'city',\n    isDirect: 'false',\n    serviceName: SERVICE_NAME[selection.service],\n    currency: ctx.currency,\n    classType: ctx.cabinCode,\n    connection: ctx.tripType,\n    directFlights: ctx.totalStops === 0,\n    flexibleDates: false,\n    legs: JSON.stringify(legsPayload),\n    // Lets the results page show an \"UPDATING NOW\" banner per changed leg.\n    updatingLegs: JSON.stringify(\n      changes.map(c => {\n        const o = legOf(c);\n        return {\n          legId: o.legId,\n          direction: o.direction,\n          originCode: o.originCode,\n          destinationCode: o.destinationCode,\n          originCityName: o.originCityName,\n          destinationCityName: o.destinationCityName,\n          originalDeparture: utcMs(o.departure),\n        };\n      }),\n    ),\n  };\n\n  if (ctx.tripType === 'RoundTrip') {\n    const secondLeg = ctx.legs[1];\n    params['return'] = routeReturn\n      ? utcMs(routeReturn)\n      : secondLeg\n        ? utcMs(secondLeg.departure) // the web parses this one in the customer's timezone; read as UTC here so it doesn't depend on the agent's timezone\n        : utcMs(String((legsPayload[0] as Raw).departDateTime));\n\n    if (changes.length === 1) {\n      const other = otherLegOf(ctx, changes[0].legId);\n      if (isDate && other && !other.isReturn) {\n        params['departure'] = utcMs(other.departDateTime);\n        params['return'] = utcMs(String((legsPayload[0] as Raw).departDateTime));\n      }\n      if (other) params['extraLeg'] = JSON.stringify(other);\n    }\n  }\n\n  if (ctx.tripType === 'MultiCity') {\n    let cities: Raw[];\n    if (isDate) {\n      const changedDate = new Map(changes.map(c => [c.legId, c.departDate]));\n      cities = ctx.legs.map(l => ({\n        departure: absoluteMs(changedDate.get(l.legId) || l.departure),\n        destination: l.destinationCode,\n        destinationType: l.destinationCode,\n        origin: l.originCode,\n        originType: l.originCode,\n        destinationCity: l.destinationCityName,\n        destinationCityName: l.destinationCityName,\n        destinationName: l.destinationCityName,\n        destinationCountryName: l.destinationCountryName,\n        originCity: l.originCityName,\n        originCityName: l.originCityName,\n        originName: l.originCityName,\n        originCountryName: l.originCountryName,\n      }));\n    } else {\n      cities = changes.map(c => {\n        const o = legOf(c);\n        const from = c.origin;\n        const to = c.destination;\n        return {\n          departure: utcMs(o.departure),\n          destination: to?.id ?? o.destinationCode,\n          destinationType: to?.type ?? o.destinationCode,\n          origin: from?.id ?? o.originCode,\n          originType: from?.id ?? o.originCode,\n          destinationCity: to?.name ?? o.destinationCityName,\n          destinationCityName: to?.name ?? o.destinationCityName,\n          destinationName: to?.name ?? o.destinationCityName,\n          destinationCountryName: to?.country_name ?? o.destinationCountryName,\n          originCity: from?.name ?? o.originCityName,\n          originCityName: from?.name ?? o.originCityName,\n          originName: from?.name ?? o.originCityName,\n          originCountryName: from?.country_name ?? o.originCountryName,\n        };\n      });\n    }\n    params['departure'] = cities[0].departure;\n    params['cities'] = JSON.stringify(cities);\n  }\n\n  params['bookingId'] = ctx.bookingId;\n  params['postBookingId'] = postBookingId;\n\n  return Object.fromEntries(\n    Object.entries(params)\n      .filter(([, v]) => v !== undefined && v !== null)\n      .map(([k, v]) => [k, String(v)]),\n  );\n}\n\nexport function buildReissueSearchUrl(\n  webBaseUrl: string,\n  ctx: ReissueBookingContext,\n  selection: ReissueSelection,\n  postBookingId: string,\n): string {\n  const qs = new URLSearchParams(buildReissueSearchParams(ctx, selection, postBookingId));\n  return `${webBaseUrl.replace(/\\/+$/, '')}${REISSUE_WEB_PATH}?${qs.toString()}`;\n}\n\n/**\n * Adds the host's auth parameters (for example its token) to the web link: in the query string, or in the `#fragment`\n * (which browsers do not send to servers or in the Referer). Empty values are skipped.\n */\nexport function appendAuthParams(url: string, params: Record<string, string>, where: 'query' | 'hash' = 'query'): string {\n  const entries = Object.entries(params ?? {}).filter(([, value]) => !!value);\n  if (!entries.length) return url;\n  const target = new URL(url);\n  if (where === 'hash') {\n    const hash = new URLSearchParams(target.hash.replace(/^#/, ''));\n    entries.forEach(([name, value]) => hash.set(name, value));\n    target.hash = hash.toString();\n  } else {\n    entries.forEach(([name, value]) => target.searchParams.set(name, value));\n  }\n  return target.toString();\n}\n"]}

package/esm2022/public-api.mjs

@@ -6,4 +6,6 @@ export { SmartBookingDashboardComponent } from './lib/pages/smart-booking-dashbo
 export { smartBookingDashboardRoutes } from './lib/smart-booking-dashboard.routes';
 export { SmartBookingDashboardModule } from './lib/smart-booking-dashboard.module';
 export { SBD_CONFIG, SBD_DEFAULT_CONFIG, provideSmartBookingDashboard } from './lib/config/dashboard.config';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLHVFQUF1RSxDQUFDO0FBQ3ZILE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ25GLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ25GLE9BQU8sRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIG9mIHRoZSBTbWFydCBCb29raW5nIERhc2hib2FyZC5cbiAqIEhvc3QgYXBwcyBzaG91bGQgaW1wb3J0IG9ubHkgZnJvbSB0aGlzIGZpbGUuXG4gKi9cbmV4cG9ydCB7IFNtYXJ0Qm9va2luZ0Rhc2hib2FyZENvbXBvbmVudCB9IGZyb20gJy4vbGliL3BhZ2VzL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkLmNvbXBvbmVudCc7XG5leHBvcnQgeyBzbWFydEJvb2tpbmdEYXNoYm9hcmRSb3V0ZXMgfSBmcm9tICcuL2xpYi9zbWFydC1ib29raW5nLWRhc2hib2FyZC5yb3V0ZXMnO1xuZXhwb3J0IHsgU21hcnRCb29raW5nRGFzaGJvYXJkTW9kdWxlIH0gZnJvbSAnLi9saWIvc21hcnQtYm9va2luZy1kYXNoYm9hcmQubW9kdWxlJztcbmV4cG9ydCB7IFNCRF9DT05GSUcsIFNCRF9ERUZBVUxUX0NPTkZJRywgcHJvdmlkZVNtYXJ0Qm9va2luZ0Rhc2hib2FyZCB9IGZyb20gJy4vbGliL2NvbmZpZy9kYXNoYm9hcmQuY29uZmlnJztcbmV4cG9ydCB0eXBlIHsgU2JkQ29uZmlnIH0gZnJvbSAnLi9saWIvY29uZmlnL2Rhc2hib2FyZC5jb25maWcnO1xuIl19
+export { buildReissueSearchUrl, buildReissueSearchParams, buildReissueBookingContext, appendAuthParams } from './lib/utils/reissue-url.builder';
+export { SBD_TOAST_HANDLER } from './lib/services/toast.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLHVFQUF1RSxDQUFDO0FBQ3ZILE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ25GLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ25GLE9BQU8sRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUU3RyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsd0JBQXdCLEVBQUUsMEJBQTBCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVoSixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIG9mIHRoZSBTbWFydCBCb29raW5nIERhc2hib2FyZC5cbiAqIEhvc3QgYXBwcyBzaG91bGQgaW1wb3J0IG9ubHkgZnJvbSB0aGlzIGZpbGUuXG4gKi9cbmV4cG9ydCB7IFNtYXJ0Qm9va2luZ0Rhc2hib2FyZENvbXBvbmVudCB9IGZyb20gJy4vbGliL3BhZ2VzL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkL3NtYXJ0LWJvb2tpbmctZGFzaGJvYXJkLmNvbXBvbmVudCc7XG5leHBvcnQgeyBzbWFydEJvb2tpbmdEYXNoYm9hcmRSb3V0ZXMgfSBmcm9tICcuL2xpYi9zbWFydC1ib29raW5nLWRhc2hib2FyZC5yb3V0ZXMnO1xuZXhwb3J0IHsgU21hcnRCb29raW5nRGFzaGJvYXJkTW9kdWxlIH0gZnJvbSAnLi9saWIvc21hcnQtYm9va2luZy1kYXNoYm9hcmQubW9kdWxlJztcbmV4cG9ydCB7IFNCRF9DT05GSUcsIFNCRF9ERUZBVUxUX0NPTkZJRywgcHJvdmlkZVNtYXJ0Qm9va2luZ0Rhc2hib2FyZCB9IGZyb20gJy4vbGliL2NvbmZpZy9kYXNoYm9hcmQuY29uZmlnJztcbmV4cG9ydCB0eXBlIHsgU2JkQ29uZmlnLCBTYmRSZWRpcmVjdEF1dGhQYXJhbXMgfSBmcm9tICcuL2xpYi9jb25maWcvZGFzaGJvYXJkLmNvbmZpZyc7XG5leHBvcnQgeyBidWlsZFJlaXNzdWVTZWFyY2hVcmwsIGJ1aWxkUmVpc3N1ZVNlYXJjaFBhcmFtcywgYnVpbGRSZWlzc3VlQm9va2luZ0NvbnRleHQsIGFwcGVuZEF1dGhQYXJhbXMgfSBmcm9tICcuL2xpYi91dGlscy9yZWlzc3VlLXVybC5idWlsZGVyJztcbmV4cG9ydCB0eXBlICogZnJvbSAnLi9saWIvbW9kZWxzL3JlaXNzdWUudHlwZXMnO1xuZXhwb3J0IHsgU0JEX1RPQVNUX0hBTkRMRVIgfSBmcm9tICcuL2xpYi9zZXJ2aWNlcy90b2FzdC5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHsgU2JkVG9hc3RIYW5kbGVyIH0gZnJvbSAnLi9saWIvc2VydmljZXMvdG9hc3Quc2VydmljZSc7XG4iXX0=