@odynn/awayz-core 0.2.25 → 0.2.26

package/dist/lib/services/account/AccountService.d.ts

@@ -0,0 +1,93 @@
+import { IAuthData, IRegion, IResendVerificationEmailParams, ISearchLimitResponse, IUser } from './AccountServices.types';
+import { TServiceResponse } from '@type-op/shared';
+import { ISignInParams, ISignUpParams } from '../../types/auth';
+export interface IClientUser {
+    _id: string;
+    email_address: string;
+    user_region: string;
+    client_id: string;
+    client_user_id: string;
+    __v: number;
+}
+/**
+ * AccountService provides methods for user authentication and account management.
+ */
+declare class _AccountService {
+    /**
+     * Logs in a user with the provided email and password.
+     *
+     * @param params - The sign-in parameters containing email and password.
+     * @returns A promise that resolves to a service response containing authentication data.
+     */
+    login: (params: ISignInParams) => Promise<{
+        success: boolean;
+        data: IAuthData;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: any;
+        data?: undefined;
+    }>;
+    /**
+     * Registers a new user with the provided email, password, and region.
+     *
+     * @param params - The sign-up parameters containing email, password, and region.
+     * @returns A promise that resolves to a service response containing authentication data.
+     */
+    signUp: (params: ISignUpParams) => Promise<{
+        success: boolean;
+        data: IAuthData;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: any;
+        data?: undefined;
+    }>;
+    resendVerificationEmail: (params: IResendVerificationEmailParams) => Promise<any>;
+    /**
+     * Authenticates a user using an ID token.
+     *
+     * @param idToken - The ID token to authenticate with.
+     * @returns A promise that resolves to a service response containing authentication data.
+     */
+    authenticateWithToken: (idToken: string) => Promise<TServiceResponse<IAuthData>>;
+    /**
+     * If token is available in local storage, check if it is valid and return user details
+     *
+     * @returns A promise that resolves to a service response containing the user details.
+     */
+    checkUser: () => Promise<TServiceResponse<IUser>>;
+    /**
+     * @description In the case of a 401 error, the refresh token is used to get a new access token and user details, by exchanging the
+     * refresh token for a new id_token and in turn exchanging that for a new awayz token
+     *
+     * @param refreshToken - The refresh token
+     */
+    refreshEmbedToken: (refreshToken: string) => Promise<TServiceResponse<{
+        user: IUser;
+        token: string;
+        id_token: string;
+    }>>;
+    /**
+     * @description In the case of a 401 error, the refresh token is used to get a new access token and user details
+     *
+     * @param refreshToken - The refresh token
+     */
+    refreshToken: (refreshToken: string) => Promise<TServiceResponse<{
+        token: string;
+    }>>;
+    /**
+     * Retrieves the request limit for the authenticated user.
+     *
+     * @returns A promise that resolves to a service response containing the request limit data.
+     */
+    getRequestLimit: () => Promise<TServiceResponse<ISearchLimitResponse[]>>;
+    /**
+     * Retrieves the regions available for user registration.
+     *
+     * @returns A promise that resolves to a service response containing the available regions.
+     */
+    getRegions: () => Promise<IRegion[]>;
+}
+export declare const AccountService: _AccountService;
+export {};

package/dist/lib/services/account/AccountServices.types.d.ts

@@ -0,0 +1,174 @@
+import { ESearchLimitType } from '@type-op/shared';
+/**
+ * @description - the awayz user after being mapped from backend response to desired shape
+ */
+export interface IUser {
+    id: string;
+    emailAddress: string;
+    emailVerified: boolean;
+    clientId: string;
+    clientUserId: string;
+    userRegion: IRegion;
+    account: IAccount;
+}
+export interface IAccount {
+    userId: string;
+    subscriptionId: string;
+    subscription: ISubscription;
+    expiresAt: string;
+    status: string;
+    stripeDetails: IStripeDetails;
+    id: string;
+}
+interface IStripeDetails {
+    subscriptionId: string;
+    priceId: string;
+    trialPeriod: number;
+}
+export interface ISubscription {
+    tier: string;
+    flightSearchLimit: number;
+    hotelSearchLimit: number;
+    hotelAvailabilityAlertLimit: number;
+    isPaid: boolean;
+    stripeProductId: string;
+    isDeleted: boolean;
+    features: IFeature[];
+    id: string;
+}
+interface IFeature {
+    key?: string;
+    text: string;
+    included: boolean;
+}
+export interface ISearchLimit {
+    isAdmin: boolean;
+    numberOfCalls: number;
+    remainingCalls: number;
+    searchLimit: number;
+    searchType: string;
+    subscription: string;
+}
+export interface IResetPasswordParams {
+    email: string;
+    password: string;
+    confirm_password: string;
+    code: string;
+}
+export interface IForgotPasswordResponse {
+    success: boolean;
+    message: string;
+    token: string;
+}
+export interface ISignInResponse {
+    success: boolean;
+    message: string;
+    data: IAuthDataResponse | null;
+}
+export interface IAuthDataResponse {
+    user: IUserResponse;
+    accessToken?: string;
+    refreshToken?: string;
+}
+export interface ISignUpResponse {
+    user: IUserResponse;
+    tokens: {
+        accessToken?: string;
+        refreshToken?: string;
+    };
+}
+export interface IAuthData {
+    user: IUser;
+    token?: string;
+    refreshToken?: string;
+}
+export interface IResendVerificationEmailParams {
+    email: string;
+    successUrl: string;
+    cancelUrl: string;
+}
+export interface IUserResponse {
+    email_address: string;
+    user_region: string;
+    client_id: string;
+    email_verified: boolean;
+    _id: string;
+}
+export interface ISpendingBreakdown {
+    Internet: number;
+    Restaurants: number;
+    Airfare: number;
+    nonAirTravel: number;
+    Gas: number;
+    Other: number;
+    Groceries: number;
+    Rent: number;
+}
+export interface IAwayzAccess {
+    id: string;
+    details: IDetails;
+    customer_id: string;
+    cancel_at_period_end: boolean;
+    active: boolean;
+    awayz_gold: boolean;
+    awayz_premium: boolean;
+    awayz_enum: string;
+}
+export interface IDetails {
+    si_id: string;
+    current_period_end: number;
+    current_period_start: number;
+    interval: string;
+    interval_count: number;
+    amount: number;
+    price_id: string;
+    product_id: string;
+    discount_amount: number;
+    original_amount: any;
+}
+export interface ICheckUserResponse {
+    success: boolean;
+    userVeri: IUser | null;
+    userData: any;
+    message?: string;
+}
+export interface IRegion {
+    id: string;
+    name: string;
+    code: string;
+    currency: string;
+    flagIcon: string;
+    isActive: boolean;
+}
+export interface IRegionResponse {
+    _id: string;
+    name: string;
+    code: string;
+    currency: string;
+    flag_icon: string;
+    is_active: boolean;
+}
+export declare enum ESource {
+    CODE = "code",
+    OFFER = "offer"
+}
+export interface IAccountResponse {
+    email_address: string;
+    password: string;
+    account_type: string;
+    price_id: string;
+    success_url: string;
+    cancel_url: string;
+    coupon?: string;
+    user_region: string;
+    user_source_id?: string;
+}
+export interface ISearchLimitResponse {
+    search_type: ESearchLimitType;
+    subscription: string;
+    is_admin: boolean;
+    search_limit: number;
+    number_of_calls: number;
+    remaining_calls: number;
+}
+export {};

package/dist/lib/services/currency/CurrencyService.d.ts

@@ -0,0 +1,15 @@
+import { IConvertCurrencyArgs } from './CurrencyService.types';
+declare class _CurrencyService {
+    convertCurrency: ({ baseCurrency }: IConvertCurrencyArgs) => Promise<number>;
+    /**
+     * Convert from base currency to target currency for the amount provided
+     * @param param0 IConvertCurrencyArgs
+     * @param baseCurrency the base currency to convert from
+     * @param targetCurrency the target currency to convert to
+     * @parm amount the amount to be converted from the base to the target currency
+     * @returns the converted amount
+     */
+    convertToCurrency: ({ baseCurrency, targetCurrency, amount }: IConvertCurrencyArgs) => Promise<number>;
+}
+export declare const CurrencyService: _CurrencyService;
+export {};

package/dist/lib/services/currency/CurrencyService.types.d.ts

@@ -0,0 +1,18 @@
+export interface IConvertCurrencyArgs {
+    baseCurrency: string;
+    targetCurrency?: string;
+    amount?: number;
+}
+export interface IConvertCurrencyResult {
+    result: string;
+    documentation: string;
+    terms_of_use: string;
+    time_last_update_unix: number;
+    time_last_update_utc: string;
+    time_next_update_unix: number;
+    time_next_update_utc: string;
+    base_code: string;
+    target_code: string;
+    conversion_rate: number;
+    conversion_result: number;
+}

package/dist/lib/services/instance.d.ts

@@ -0,0 +1,2 @@
+export declare const instance: import('axios').AxiosInstance;
+export declare const clientInstance: import('axios').AxiosInstance;

package/dist/lib/services/wallet/WalletService.d.ts

@@ -0,0 +1,9 @@
+import { IBank, ICard, ILoyaltyProgram } from './WalletService.types';
+declare class _WalletService {
+    getAwards: () => Promise<ILoyaltyProgram[]>;
+    setAwardPoints: (main_program: string, amount: number) => Promise<any>;
+    getBanks: () => Promise<IBank[]>;
+    getCards: () => Promise<ICard[]>;
+}
+export declare const WalletService: _WalletService;
+export {};

package/dist/lib/services/wallet/WalletService.types.d.ts

@@ -0,0 +1,61 @@
+import { ERewardProgramCategory } from '@type-op/shared';
+export interface IStatusLevels {
+    level1: string;
+    level2: string;
+    level3: string;
+    level4: string;
+    level5: string;
+}
+export interface ILoyaltyProgram {
+    id: string;
+    mainProgram: string;
+    category: ERewardProgramCategory;
+    statusLevels: IStatusLevels;
+    displayProgram: string;
+    awayzActive: string[];
+    modified: string;
+    colour: string;
+    programLogo: string;
+    url: string;
+    faredropUrl: string;
+    categoryLogo: string;
+    alternateRegions: string[];
+    region: string;
+    totalAccumulatedPoints: number;
+}
+export interface IBank {
+    id: string;
+    created: string;
+    name: string;
+    code: string;
+    mxCode: string;
+    rank: number;
+    modified: string;
+    region: string;
+    alternateRegions: string[];
+}
+export interface ICard {
+    id: string;
+    name: string;
+    signupBonus: number;
+    cashBonus: number;
+    minimumSpend: number;
+    daysToSpend: number;
+    annualFee: number;
+    annualFeeWaived: boolean;
+    cashPerks: number;
+    bank: {
+        name: string;
+    };
+    rewardsCurrency: string;
+    bisCard: boolean;
+    chargeCard: boolean;
+    cardFamily: number;
+    websiteUrl: string;
+    network: {
+        name: string;
+    };
+    colour: string;
+    region: string;
+    alternateRegions: string[];
+}

package/dist/lib/types/EAuthFlow.d.ts

@@ -0,0 +1,9 @@
+export declare enum EAuthFlow {
+    STANDARD = "standard",
+    /** Pass the token in using window.postmessage */
+    POST_MESSAGE = "postMessage",
+    /** Not yet supported */
+    OAUTH = "oauth",
+    /** Pass the token as a query param */
+    QUERY = "query"
+}

package/dist/lib/types/auth.d.ts

@@ -0,0 +1,22 @@
+import { IAuthData } from '../services/account/AccountServices.types';
+export interface ISignUpParams {
+    email: string;
+    password: string;
+    region: string;
+    successUrl?: string;
+    cancelUrl?: string;
+    priceId: string;
+}
+export interface ISignInParams {
+    email: string;
+    password: string;
+}
+export type TAuthResponse = {
+    success: boolean;
+    data: IAuthData;
+    message?: undefined;
+} | {
+    success: boolean;
+    message: any;
+    data?: undefined;
+};

package/dist/lib/types/index.d.ts

@@ -0,0 +1 @@
+export * from './EAuthFlow';

package/dist/main.js

@@ -0,0 +1,25 @@
+import { AwayzProvider as e } from "./providers/AwayzProvider.js";
+import { useAwayzContext as a } from "./hooks/useAwayzContext.js";
+import { useSearchLimit as p } from "./hooks/useSearchLimit.js";
+import { useWallet as f } from "./hooks/useWallet.js";
+import { EAuthFlow as s } from "./types/EAuthFlow.js";
+import { c as l, i as c } from "./AccountService-BmvBvxkG.js";
+import { awayzClient as w } from "./configs/awayzClient.js";
+import { CashValue as C } from "./components/CashValue/CashValue.js";
+import { EToolTipPosition as z } from "./components/CashValue/CashValueTypes.js";
+import { CurrencyService as v } from "./services/currency/CurrencyService.js";
+import { getBaseUrl as P } from "./configs/baseUrl.js";
+export {
+  e as AwayzProvider,
+  C as CashValue,
+  v as CurrencyService,
+  s as EAuthFlow,
+  z as EToolTipPosition,
+  w as awayzClient,
+  l as clientInstance,
+  P as getBaseUrl,
+  c as instance,
+  a as useAwayzContext,
+  p as useSearchLimit,
+  f as useWallet
+};

package/dist/providers/AwayzProvider.js

@@ -0,0 +1,40 @@
+import { jsx as t } from "react/jsx-runtime";
+import { useEffect as i } from "react";
+import { AwayzContext as m } from "../context/AwayzContext.js";
+import { E as e } from "../AccountService-BmvBvxkG.js";
+import { useAwayzAuth as s } from "../hooks/useAwayzAuth/useAwayzAuth.js";
+import { setBaseUrl as l } from "../configs/baseUrl.js";
+import { QueryClientProvider as u } from "@tanstack/react-query";
+import { awayzClient as d } from "../configs/awayzClient.js";
+import '../assets/_styles.css';/* empty css                                      */
+import { defaultAwayzConfig as n } from "../configs/defaultAwayzConfig.js";
+const C = ({ children: o, config: r }) => {
+  const a = s({
+    authFlow: r.authFlow,
+    onSuccess: r.onAuthSuccess,
+    onError: r.onAuthFailure,
+    trustedOrigins: r.trustedOrigins
+  });
+  return i(() => {
+    if (!r.clientId) {
+      console.error("You need to provide a client ID to the AwayzProvider");
+      return;
+    }
+    localStorage.setItem(e.CLIENT_ID, r.clientId), localStorage.setItem(e.AUTH_FLOW, r.authFlow), l(r.testMode ?? !1);
+  }, [r]), /* @__PURE__ */ t(u, { client: d, children: /* @__PURE__ */ t(
+    m.Provider,
+    {
+      value: {
+        ...a,
+        config: {
+          ...n,
+          ...r
+        }
+      },
+      children: o
+    }
+  ) });
+};
+export {
+  C as AwayzProvider
+};

package/dist/services/account/AccountService.js

@@ -0,0 +1,7 @@
+import { e as m } from "../../AccountService-BmvBvxkG.js";
+import "react";
+import "../../configs/endpoints.js";
+import "../../configs/awayzClient.js";
+export {
+  m as AccountService
+};

package/dist/services/account/AccountServices.types.js

@@ -0,0 +1,4 @@
+var e = /* @__PURE__ */ ((r) => (r.CODE = "code", r.OFFER = "offer", r))(e || {});
+export {
+  e as ESource
+};

package/dist/services/currency/CurrencyService.js

@@ -0,0 +1,66 @@
+import '../../assets/_styles.css';var i = Object.defineProperty;
+var y = (t, r, e) => r in t ? i(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
+var o = (t, r, e) => y(t, typeof r != "symbol" ? r + "" : r, e);
+import { e as p, a as C, c as a } from "../../AccountService-BmvBvxkG.js";
+import "react";
+import { ECurrencyEndpoints as s } from "../../configs/endpoints.js";
+import "react/jsx-runtime";
+import "../../context/AwayzContext.js";
+import { awayzClient as m } from "../../configs/awayzClient.js";
+import "@tanstack/react-query";
+/* empty css                                         */
+class E {
+  constructor() {
+    o(this, "convertCurrency", async ({
+      baseCurrency: r
+    }) => {
+      try {
+        const { success: e, data: n } = await m.ensureQueryData({
+          queryKey: [C.CHECK_USER],
+          queryFn: p.checkUser
+        });
+        if (!e)
+          throw new Error("Failed to fetch user data");
+        const { userRegion: c } = n, { data: u } = await a.post(s.CURRENCY_CONVERSION, {
+          target_currency: c.currency,
+          base_currency: r
+        });
+        if (e)
+          return u.data.conversion_rate;
+      } catch (e) {
+        console.error(e);
+      }
+      return 0;
+    });
+    /**
+     * Convert from base currency to target currency for the amount provided
+     * @param param0 IConvertCurrencyArgs
+     * @param baseCurrency the base currency to convert from
+     * @param targetCurrency the target currency to convert to
+     * @parm amount the amount to be converted from the base to the target currency
+     * @returns the converted amount
+     */
+    o(this, "convertToCurrency", async ({
+      baseCurrency: r,
+      targetCurrency: e,
+      amount: n
+    }) => {
+      try {
+        const { data: c } = await a.post(s.CURRENCY_CONVERSION, {
+          target_currency: e,
+          base_currency: r,
+          amount: n
+        });
+        if (c.success)
+          return c.data.conversion_result;
+      } catch (c) {
+        console.error(c);
+      }
+      return 0;
+    });
+  }
+}
+const h = new E();
+export {
+  h as CurrencyService
+};

package/dist/services/currency/CurrencyService.types.js

@@ -0,0 +1 @@
+

package/dist/services/instance.js

@@ -0,0 +1,9 @@
+import { c as p, i as a } from "../AccountService-BmvBvxkG.js";
+import "react";
+import "../configs/endpoints.js";
+import "../configs/baseUrl.js";
+import "../types/EAuthFlow.js";
+export {
+  p as clientInstance,
+  a as instance
+};

package/dist/services/wallet/WalletService.js

@@ -0,0 +1,84 @@
+import '../../assets/_styles.css';var y = Object.defineProperty;
+var w = (e, a, t) => a in e ? y(e, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[a] = t;
+var o = (e, a, t) => w(e, typeof a != "symbol" ? a + "" : a, t);
+import { b as s, c as i, d as n } from "../../AccountService-BmvBvxkG.js";
+import "react";
+import "react/jsx-runtime";
+import "../../context/AwayzContext.js";
+import { EWalletEndpoints as m } from "../../configs/endpoints.js";
+import "../../configs/awayzClient.js";
+import "@tanstack/react-query";
+/* empty css                                         */
+class E {
+  constructor() {
+    o(this, "getAwards", async () => {
+      var a, t, c;
+      try {
+        const l = [
+          s.HOTEL,
+          s.BANK,
+          s.AIRLINE
+        ], [
+          { data: d },
+          { data: p },
+          { data: g }
+        ] = await Promise.all(
+          l.map(
+            (r) => i.get(
+              m.USER_AWARDS,
+              {
+                params: { category: r }
+              }
+            )
+          )
+        ), u = ((a = d.data) == null ? void 0 : a.map(
+          (r) => n({
+            ...r,
+            ctegory: s.HOTEL
+          })
+        )) ?? [], A = ((t = p.data) == null ? void 0 : t.map(
+          (r) => n({
+            ...r,
+            ctegory: s.BANK
+          })
+        )) ?? [], R = ((c = g.data) == null ? void 0 : c.map(
+          (r) => n({
+            ...r,
+            ctegory: s.AIRLINE
+          })
+        )) ?? [];
+        return [
+          ...u,
+          ...A,
+          ...R
+        ];
+      } catch (l) {
+        console.error(l);
+      }
+      return [];
+    });
+    o(this, "setAwardPoints", async (a, t) => {
+      const { data: c } = await i.put(m.USER_AWARDS, {
+        main_program: a,
+        amount: t
+      });
+      return c;
+    });
+    o(this, "getBanks", async () => {
+      const { data: a } = await i.get(
+        m.BANKS
+      );
+      return a.success ? a.data.map((t) => n(t)) : [];
+    });
+    o(this, "getCards", async () => {
+      const { data: a } = await i.get(
+        m.CARDS
+      );
+      return a.success ? a.data.map((t) => n(t)) : [];
+    });
+  }
+}
+const b = new E();
+export {
+  b as WalletService
+};

package/dist/services/wallet/WalletService.types.js

@@ -0,0 +1 @@
+

package/dist/types/EAuthFlow.js

@@ -0,0 +1,4 @@
+var a = /* @__PURE__ */ ((r) => (r.STANDARD = "standard", r.POST_MESSAGE = "postMessage", r.OAUTH = "oauth", r.QUERY = "query", r))(a || {});
+export {
+  a as EAuthFlow
+};

package/dist/types/auth.js

@@ -0,0 +1 @@
+

package/dist/types/index.js

@@ -0,0 +1,4 @@
+import { EAuthFlow as t } from "./EAuthFlow.js";
+export {
+  t as EAuthFlow
+};