@duffel/components 2.7.20 → 3.0.0

package/src/tests/lib/hasServiceOfSameMetadataTypeAlreadyBeenSelected.test.ts

@@ -0,0 +1,86 @@
+import { hasServiceOfSameMetadataTypeAlreadyBeenSelected } from "../../lib/hasServiceOfSameMetadataTypeAlreadyBeenSelected";
+import { CreateOrderPayloadService } from "../../types/CreateOrderPayload";
+import { OfferAvailableBaggageService } from "../../types/Offer";
+
+const availableService: OfferAvailableBaggageService = {
+  id: "available_service_id",
+  metadata: { type: "checked" },
+  // using as any because we don't need to test the whole type
+} as any;
+
+const selectedService: CreateOrderPayloadService = {
+  id: "selected_service_id",
+  serviceInformation: {
+    segmentId: "segment_id",
+    passengerId: "passenger_id",
+    type: "checked",
+  },
+} as any;
+
+describe("hasServiceOfSameMetadataTypeAlreadyBeenSelected", () => {
+  it("Should return false if no services selected", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [],
+        "segment_id",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected is the availableService we are checking", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [{ ...selectedService, id: availableService.id }],
+        "segment_id",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected are for different passenger", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id",
+        "passenger_id_wont_match",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected are for different segment", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id_wont_match",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(false);
+  });
+
+  it("Should return false if service selected is of different type", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id",
+        "passenger_id",
+        { ...availableService, metadata: { type: "carry_on" } } as any
+      )
+    ).toBe(false);
+  });
+
+  it("Should return true if service selected is of same type for same passenger and segment", () => {
+    expect(
+      hasServiceOfSameMetadataTypeAlreadyBeenSelected(
+        [selectedService],
+        "segment_id",
+        "passenger_id",
+        availableService
+      )
+    ).toBe(true);
+  });
+});

package/src/tests/lib/logging.test.tsx

@@ -0,0 +1,32 @@
+import { initializeLogger, log, logGroup } from "../../lib/logging";
+
+const consoleSpies = {
+  log: jest.spyOn(console, "info"),
+  groupCollapsed: jest.spyOn(console, "groupCollapsed"),
+  groupEnd: jest.spyOn(console, "groupEnd"),
+};
+
+describe("logging", () => {
+  it("should return functions that do nothing when debugMode is false", () => {
+    initializeLogger(false);
+    log("This should not be logged");
+    expect(consoleSpies.log).not.toHaveBeenCalled();
+  });
+
+  it("should return functions that log a message when debugMode is true", () => {
+    initializeLogger(true);
+    log("This should be logged");
+
+    // Once because initializeLogger was initialised on the test above
+    // And so, the initialisation message would not show up twice.
+    expect(consoleSpies.log).toHaveBeenCalledTimes(1);
+
+    logGroup("This should be logged", ["one", "two"]);
+    expect(consoleSpies.groupCollapsed).toHaveBeenCalledTimes(1);
+    expect(consoleSpies.groupEnd).toHaveBeenCalledTimes(1);
+
+    // once for the call to `log` above and then
+    // twice for the array passed to logGroup
+    expect(consoleSpies.log).toHaveBeenCalledTimes(3);
+  });
+});

package/src/tests/lib/moneyStringFormatter.test.tsx

@@ -0,0 +1,12 @@
+import { moneyStringFormatter } from "../../lib/moneyStringFormatter";
+
+describe("moneyStringFormatter", () => {
+  it("should format known currencies correctly", () => {
+    expect(moneyStringFormatter("GBP")(10.23)).toEqual("£10.23");
+  });
+  it("should fall back to value + currency for unknown currencies", () => {
+    expect(moneyStringFormatter("Duffel house points")(10.23)).toEqual(
+      "10.23 Duffel house points"
+    );
+  });
+});

package/src/tests/lib/validateProps.test.tsx

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/**
+ * In this file, we want to allow usage of @ts-ignore so
+ * that we can test functions with invalid props.
+ */
+
+import { hasCommonRequiredProps } from "../../lib/validateProps";
+import { Ancillaries } from "../../types/DuffelAncillariesProps";
+
+describe("hasCommonRequiredProps", () => {
+  it("should pass when all required props are provided", () => {
+    const props = {
+      onPayloadReady: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+      passengers: [],
+      services: ["bags"] as Ancillaries[],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+    expect(hasCommonRequiredProps(props)).toBeTruthy();
+  });
+
+  it("should fail when services is missing", () => {
+    const props = {
+      onPayloadReady: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+      passengers: [],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+
+    // @ts-ignore
+    expect(hasCommonRequiredProps(props)).toBeFalsy();
+  });
+
+  it("should fail when onPayloadReady is missing", () => {
+    const props = {
+      passengers: [],
+      services: ["bags"] as Ancillaries[],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+
+    // @ts-ignore
+    expect(hasCommonRequiredProps(props)).toBeFalsy();
+  });
+
+  it("should fail when passengers is missing", () => {
+    const props = {
+      onPayloadReady: () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
+      services: ["bags"] as Ancillaries[],
+      offer_id: "offer_id",
+      client_key: "client_key",
+    };
+
+    // @ts-ignore
+    expect(hasCommonRequiredProps(props)).toBeFalsy();
+  });
+});

package/src/types/Aircraft.ts

@@ -0,0 +1,16 @@
+export interface Aircraft {
+  /**
+   * The three-character IATA code for the aircraft
+   */
+  iata_code: string;
+
+  /**
+   * Duffel's unique identifier for the aircraft
+   */
+  id: string;
+
+  /**
+   * The name of the aircraft
+   */
+  name: string;
+}

package/src/types/Airline.ts

@@ -0,0 +1,16 @@
+export interface Airline {
+  /**
+   * The two-character IATA code for the airline. This may be null for non-IATA carriers.
+   */
+  iata_code: string | null;
+
+  /**
+   * Duffel's unique identifier for the airline
+   */
+  id: string;
+
+  /**
+   * The name of the airline
+   */
+  name: string;
+}

package/src/types/Airport.ts

@@ -0,0 +1,54 @@
+import { City } from "./City";
+
+export interface Airport {
+  /**
+   * The three-character IATA code for the airport
+   */
+  iata_code: string | null;
+
+  /**
+   * Duffel's unique identifier for the airport
+   */
+  id: string;
+
+  /**
+   * The name of the airport
+   */
+  name: string;
+
+  /**
+   * The ISO 3166-1 alpha-2 code for the country where the airport is located
+   */
+  iata_country_code: string;
+
+  /**
+   * The latitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -90° and 90°
+   */
+  latitude: number;
+
+  /**
+   * The longitude position of the airport represented in Decimal degrees with 6 decimal points with a range between -180° and 180°
+   */
+  longitude: number;
+
+  /**
+   * The four-character ICAO code for the airport
+   */
+  icao_code: string | null;
+
+  /**
+   * The time zone of the airport, specified by name from the [tz database](https://en.wikipedia.org/wiki/Tz_database)
+   */
+  time_zone: string;
+
+  /**
+   * The name of the city (or cities separated by a `/`) where the airport is located
+   */
+  city_name: string;
+
+  /**
+   * The metropolitan area where the airport is located.
+   * Only present for airports which are registered with IATA as belonging to a metropolitan area.
+   */
+  city: City;
+}

package/src/types/City.ts

@@ -0,0 +1,21 @@
+export interface City {
+  /**
+   * The three-character IATA code for the city
+   */
+  iata_code: string;
+
+  /**
+   * Duffel's unique identifier for the city
+   */
+  id: string;
+
+  /**
+   * The ISO 3166-1 alpha-2 code for the country where the city is located
+   */
+  iata_country_code: string;
+
+  /**
+   * The name of the city
+   */
+  name: string;
+}

package/src/types/CreateOrderPayload.ts

@@ -0,0 +1,99 @@
+import {
+  Offer,
+  OfferAvailableCancelForAnyReasonServiceMetadata,
+  OfferAvailableServiceBaggageMetadata,
+} from "./Offer";
+
+export interface CreateOrderPayload {
+  selected_offers: Array<Offer["id"]>;
+  passengers: CreateOrderPayloadPassengers;
+  services: CreateOrderPayloadServices;
+  payments: Array<CreateOrderPayloadPayment>;
+  type: "instant";
+  metadata: Record<string, string>;
+}
+
+export interface CreateOrderPayloadPassenger {
+  id: string;
+  given_name: string;
+  family_name: string;
+  gender: string;
+  title: string;
+  born_on: string;
+  email?: string;
+  phone_number?: string;
+}
+
+export type CreateOrderPayloadPassengers = Array<CreateOrderPayloadPassenger>;
+
+export type CreateOrderPayloadPaymentType = "balance";
+
+export interface CreateOrderPayloadPayment {
+  type: CreateOrderPayloadPaymentType;
+  amount: string;
+  currency: string;
+}
+
+export type CreateOrderPayloadServices = CreateOrderPayloadService[];
+
+export interface CreateOrderPayloadService {
+  id: string;
+  quantity: number;
+
+  /** `serviceInformation` is meant for:
+   * 1. internal use within the Duffel Ancillaries component, so it is convenient to augument selected services with data about it.
+   * 2. When `onPayloadReady` is ready, we'll return selected bags and seat services along with the `serviceInformation` to allow consumer to enrich their price breakdown.
+   *
+   * Note: `serviceInformation` is not known by the Duffel API.
+   */
+  serviceInformation?: CreateOrderPayloadServiceInformation;
+}
+
+export interface CreateOrderPayloadSeatService {
+  id: string;
+  quantity: number;
+
+  /** `serviceInformation` is meant for:
+   * 1. internal use within the Duffel Ancillaries component, so it is convenient to augument selected services with data about it.
+   * 2. When `onPayloadReady` is ready, we'll return selected bags and seat services along with the `serviceInformation` to allow consumer to enrich their price breakdown.
+   *
+   * Note: `serviceInformation` is not known by the Duffel API.
+   */
+  serviceInformation?: CreateOrderPayloadServiceInformationForSeats;
+}
+
+type CreateOrderPayloadServiceInformation =
+  | CreateOrderPayloadServiceInformationForSeats
+  | CreateOrderPayloadServiceInformationForBags
+  | CreateOrderPayloadServiceInformationForCancelForAnyReason;
+
+interface CreateOrderPayloadCommonServiceInformation {
+  segmentId: string;
+  passengerId: string;
+  passengerName: string;
+  total_amount: string;
+  total_currency: string;
+}
+
+export interface CreateOrderPayloadServiceInformationForSeats
+  extends CreateOrderPayloadCommonServiceInformation {
+  type: "seat";
+  designator: string;
+  disclosures: string[];
+}
+
+export type CreateOrderPayloadServiceInformationForBags =
+  CreateOrderPayloadCommonServiceInformation &
+    OfferAvailableServiceBaggageMetadata;
+
+export type CreateOrderPayloadServiceInformationForCancelForAnyReason = {
+  type: "cancel_for_any_reason";
+} & Pick<
+  CreateOrderPayloadCommonServiceInformation,
+  /**
+   * only using `total_amount` and `total_currency` from `CreateOrderPayloadCommonServiceInformation`
+   * because the cancel for any reason service applies to the whole order, not a specific segment or passenger
+   */
+  "total_amount" | "total_currency"
+> &
+  OfferAvailableCancelForAnyReasonServiceMetadata;

package/src/types/CurrencyConversion.ts

@@ -0,0 +1,10 @@
+export interface CurrencyConversion {
+  /**
+   * currency The ISO-4217 currency code to be used
+   */
+  currency: string;
+  /**
+   * Conversion multiple to be applied to all prices
+   */
+  rate: number;
+}

package/src/types/DuffelAncillariesProps.ts

@@ -0,0 +1,108 @@
+import {
+  CreateOrderPayload,
+  CreateOrderPayloadServices,
+} from "./CreateOrderPayload";
+import {
+  Offer,
+  OfferAvailableServiceBaggage,
+  OfferAvailableServiceCancelForAnyReason,
+} from "./Offer";
+import { SeatMap, SeatMapCabinRowSectionAvailableService } from "./SeatMap";
+
+export type DuffelAncillariesProps =
+  | DuffelAncillariesPropsWithOfferIdForFixture
+  | DuffelAncillariesPropsWithClientKeyAndOfferId
+  | DuffelAncillariesPropWithOfferAndClientKey
+  | DuffelAncillariesPropsWithOffersAndSeatMaps;
+
+export interface DuffelAncillariesCommonProps {
+  styles?: CustomStyles;
+  onPayloadReady: OnPayloadReady;
+  passengers: CreateOrderPayload["passengers"];
+  services: Ancillaries[];
+  markup?: DuffelAncillariesMarkup;
+  priceFormatters?: DuffelAncillariesPriceFormatters;
+  debug?: boolean;
+}
+
+export interface DuffelAncillariesPropsWithOfferIdForFixture
+  extends DuffelAncillariesCommonProps {
+  offer_id: `fixture_${string}`;
+}
+
+export interface DuffelAncillariesPropsWithClientKeyAndOfferId
+  extends DuffelAncillariesCommonProps {
+  offer_id: string;
+  client_key: string;
+}
+
+export interface DuffelAncillariesPropWithOfferAndClientKey
+  extends DuffelAncillariesCommonProps {
+  offer: Offer;
+  client_key: string;
+}
+
+export interface DuffelAncillariesPropsWithOffersAndSeatMaps
+  extends DuffelAncillariesCommonProps {
+  offer: Offer;
+  seat_maps: SeatMap[];
+}
+
+export type DuffelAncillariesMarkupDefinition = {
+  rate: number;
+  amount: number;
+};
+
+export interface DuffelAncillariesMarkup {
+  bags?: DuffelAncillariesMarkupDefinition;
+  seats?: DuffelAncillariesMarkupDefinition;
+  cancel_for_any_reason?: DuffelAncillariesMarkupDefinition;
+}
+
+export type DuffelAncillariesPriceFormatterForBags = (
+  amount: number,
+  currency: string,
+  service: OfferAvailableServiceBaggage
+) => { amount: number; currency?: string };
+
+export type DuffelAncillariesPriceFormatterForSeats = (
+  amount: number,
+  currency: string,
+  service: SeatMapCabinRowSectionAvailableService
+) => { amount: number; currency?: string };
+
+export type DuffelAncillariesPriceFormatterForCancelForAnyReason = (
+  amount: number,
+  currency: string,
+  service: OfferAvailableServiceCancelForAnyReason
+) => { amount: number; currency?: string };
+
+export interface DuffelAncillariesPriceFormatters {
+  bags?: DuffelAncillariesPriceFormatterForBags;
+  seats?: DuffelAncillariesPriceFormatterForSeats;
+  cancel_for_any_reason?: DuffelAncillariesPriceFormatterForCancelForAnyReason;
+}
+
+export interface CustomStyles {
+  accentColor?: string;
+  buttonCornerRadius?: string;
+  fontFamily?: string;
+}
+
+export type OnPayloadReady = (
+  data: CreateOrderPayload,
+  metadata: OnPayloadReadyMetadata
+) => void;
+
+export interface OnPayloadReadyMetadata {
+  offer_total_amount: Offer["total_amount"];
+  offer_total_currency: Offer["total_currency"];
+  offer_tax_amount: Offer["tax_amount"];
+  offer_tax_currency: Offer["tax_currency"];
+
+  baggage_services: CreateOrderPayloadServices;
+  seat_services: CreateOrderPayloadServices;
+  cancel_for_any_reason_services: CreateOrderPayloadServices;
+}
+
+export type Ancillaries = "bags" | "seats" | "cancel_for_any_reason";