@odynn/awayz-core 0.2.0

package/dist/configs/awayzClient.js

@@ -0,0 +1,12 @@
+import { QueryClient as e } from "@tanstack/react-query";
+const i = new e({
+  defaultOptions: {
+    queries: {
+      staleTime: 1e3 * 60 * 5
+      // 5 minutes
+    }
+  }
+});
+export {
+  i as awayzClient
+};

package/dist/configs/awayzConfig.js

@@ -0,0 +1 @@
+

package/dist/configs/baseUrl.js

@@ -0,0 +1,8 @@
+let t = "";
+const n = () => t, s = (e) => {
+  t = e ? "https://appdev.odynn.info:3003" : "https://app.odynn.info:3003";
+};
+export {
+  n as getBaseUrl,
+  s as setBaseUrl
+};

package/dist/configs/defaultAwayzConfig.js

@@ -0,0 +1,11 @@
+const e = {
+  testMode: !1,
+  externalInventory: !1,
+  flightsConfig: {
+    streamTimeoutPingCount: 3,
+    streamTimeoutTotalSeconds: 180
+  }
+};
+export {
+  e as defaultAwayzConfig
+};

package/dist/configs/endpoints.js

@@ -0,0 +1,5 @@
+var r = /* @__PURE__ */ ((e) => (e.SIGN_IN = "auth/user-login", e.SIGN_UP = "auth/sign-up", e.ME = "user", e.RESEND_VERIFICATION_EMAIL = "auth/resend-verification-email", e.UPDATE_USER_DETAILS = "account/update/user", e.CONFIRM_EMAIL = "account/verifyAccount", e.FORGOT_PASSWORD = "email/sendVeri", e.RESEND_OTP = "email/sendForgotPasswordVerification", e.RESET_PASSWORD = "account/updateUserPassword", e.REQUEST_LIMIT = "user/request-limit", e.APPLE_SOCIAL_SIGN_UP = "tp/apple/get/user", e.GOOGLE_SOCIAL_SIGN_UP = "tp/google/get/user", e.UPDATE_USER = "account/details/addUserDetails", e.ACKNOWLEDGEMENT = "account/update/userAcknowledgement", e.REGIONS = "user/region", e.UPDATE_USER_REGION = "/account/update/userRegion", e.UPDATE_PASSENGER_DETAILS = "/account/awayz", e.EXCHANGE_TOKEN = "user/exchange-token", e.REFRESH_TOKEN = "user/refresh-token", e.OAUTH_INITIATE = "user/oauth2/initiate", e.OAUTH_CALLBACK = "user/oauth2/callback", e))(r || {}), a = /* @__PURE__ */ ((e) => (e.CURRENCY_CONVERSION = "currency/convert", e))(a || {});
+export {
+  r as EAuthEndpoints,
+  a as ECurrencyEndpoints
+};

package/dist/context/AwayzContext.js

@@ -0,0 +1,16 @@
+import { createContext as s } from "react";
+const t = s({
+  isAuthenticated: !1,
+  isAuthenticating: !1,
+  supportedRegions: [],
+  signIn: async () => ({ success: !1, message: "No Awayz Context" }),
+  signUp: async () => ({ success: !1, message: "Not Awayz Context" }),
+  signOut: () => {
+  },
+  resendVerificationEmail: async () => !1,
+  setTokens: () => {
+  }
+});
+export {
+  t as AwayzContext
+};

package/dist/hooks/useAwayzAuth/useAwayzAuth.js

@@ -0,0 +1,168 @@
+import { A as N, E as r, a as u, b as F } from "../../AccountService-BjwUydb_.js";
+import { useState as m, useCallback as x, useEffect as w } from "react";
+import { EAuthFlow as k } from "../../types/EAuthFlow.js";
+import { awayzClient as U } from "../../configs/awayzClient.js";
+const i = (t, a) => {
+  var f, E;
+  let c = "", d = a;
+  typeof a == "string" ? c = a : a instanceof N ? (c = a.message, d = {
+    message: a.message,
+    cause: a.cause,
+    status: a.status,
+    data: (f = a == null ? void 0 : a.response) == null ? void 0 : f.data
+  }) : c = a.message, (E = window.parent) == null || E.postMessage(
+    {
+      type: "auth_error",
+      details: { message: c, action: t, info: d }
+    },
+    "*"
+  );
+}, L = (t) => {
+  const [a, c] = m(!0), [d, f] = m(!1), [E, S] = m(), [R, T] = m(), [O, _] = m([]), h = x(
+    async (s) => {
+      t != null && t.onSuccess && (t == null || t.onSuccess(s)), t != null && t.onSuccessAsync && await (t == null ? void 0 : t.onSuccessAsync(s)), c(!1), f(!0), S(s.token), T(s.user);
+    },
+    [t]
+  ), y = async (s) => {
+    try {
+      const { success: e, data: n, message: o } = await u.authenticateWithToken(s);
+      if (!e) {
+        i("exchange_token", o);
+        return;
+      }
+      if (!(n != null && n.token)) {
+        i(
+          "exchange_token",
+          "no awayz token returned after exchanging id token"
+        );
+        return;
+      }
+      localStorage.setItem(r.TOKEN, n.token), await h(n);
+      const { data: g, ...l } = await u.getRequestLimit();
+      if (!l.success) {
+        console.error({ reqLimitError: l });
+        return;
+      }
+      g == null || g.forEach(
+        (A) => window.parent.postMessage(
+          {
+            type: "request_limit",
+            limit: A
+          },
+          "*"
+        )
+      );
+    } catch (e) {
+      console.error("error handling message", e);
+    } finally {
+      c(!1);
+    }
+  }, I = async () => {
+    try {
+      const { success: s, data: e } = await U.ensureQueryData({
+        queryKey: [F.CHECK_USER],
+        queryFn: u.checkUser
+      });
+      if (!s) {
+        i("exchange_token", e);
+        return;
+      }
+      await h({
+        user: e,
+        token: localStorage.getItem(r.TOKEN)
+      });
+    } catch (s) {
+      i("exchange_token", s);
+    } finally {
+      c(!1);
+    }
+  };
+  w(() => {
+    if (t.authFlow !== k.OAUTH) return;
+    const s = localStorage.getItem(r.TOKEN), e = localStorage.getItem(r.REFRESH_TOKEN);
+    s && e ? I() : c(!1);
+  }, []);
+  const K = async () => {
+    const s = await u.getRegions();
+    _(s);
+  };
+  return w(() => {
+    K();
+  }, []), w(() => {
+    if (t.authFlow !== k.QUERY) return;
+    const e = new URLSearchParams(window.location.search).get(r.TOKEN);
+    e && y(e);
+  }, []), w(() => {
+    if (t.authFlow !== k.POST_MESSAGE) return;
+    const s = async (e) => {
+      var g;
+      if (e.data.type !== "auth") return;
+      const n = (g = e.data) == null ? void 0 : g.idToken, o = e.data.refreshToken;
+      if (!n) {
+        const l = `received message ${JSON.stringify(
+          e.data
+        )}
+ no idToken in body`;
+        i("exchange_token", l);
+        return;
+      }
+      if (!o) {
+        const l = `received message: ${JSON.stringify(
+          e.data
+        )}
+ no refreshToken in body`;
+        i("refresh_token", l);
+        return;
+      }
+      localStorage.setItem(r.REFRESH_TOKEN, o), await y(n);
+    };
+    return window.addEventListener("message", s), window.parent && window.parent.postMessage(
+      {
+        type: "ready"
+        /* READY */
+      },
+      "*"
+    ), () => {
+      window.removeEventListener("message", s);
+    };
+  }, []), {
+    isAuthenticating: a,
+    isAuthenticated: d,
+    token: E,
+    user: R,
+    supportedRegions: O,
+    signIn: async (s) => {
+      var n;
+      const e = await u.login(s);
+      if (!e.success)
+        i("exchange_token", e.message);
+      else {
+        const o = (n = e.data) == null ? void 0 : n.refreshToken;
+        localStorage.setItem(r.REFRESH_TOKEN, o), await h(e.data);
+      }
+      return e;
+    },
+    signUp: async (s) => {
+      var n;
+      const e = await u.signUp(s);
+      if (!e.success)
+        i("exchange_token", e.message);
+      else {
+        const o = (n = e.data) == null ? void 0 : n.refreshToken;
+        localStorage.setItem(r.REFRESH_TOKEN, o), await h(e.data);
+      }
+      return e;
+    },
+    signOut: () => {
+      localStorage.removeItem(r.TOKEN), localStorage.removeItem(r.REFRESH_TOKEN), f(!1), S(void 0), T(void 0);
+    },
+    resendVerificationEmail: async (s) => (await u.resendVerificationEmail(s)).success,
+    setTokens: (s, e) => {
+      localStorage.setItem(r.TOKEN, s), localStorage.setItem(r.REFRESH_TOKEN, e), y(s);
+    }
+  };
+};
+export {
+  i as authFailurePostMessage,
+  L as useAwayzAuth
+};

package/dist/hooks/useAwayzAuth/useAwayzAuth.types.js

@@ -0,0 +1 @@
+

package/dist/hooks/useAwayzContext.js

@@ -0,0 +1,13 @@
+import { useContext as r } from "react";
+import { AwayzContext as t } from "../context/AwayzContext.js";
+const a = () => {
+  const o = r(t);
+  if (!o)
+    throw new Error(
+      "Awayz Components must be wrapped in an AwayzProvider. Visit https://docs.awayz.com/providers/awayzprovider for more information."
+    );
+  return o;
+};
+export {
+  a as useAwayzContext
+};

package/dist/lib/components/CashValue/CashValue.d.ts

@@ -0,0 +1,14 @@
+export interface ICashValueProps {
+    amount: number | string;
+    currency: string;
+    position?: EToolTipPosition;
+}
+export declare const CurrencyCallStaleTimeMs: number;
+declare const CashValue: ({ amount, currency, position }: ICashValueProps) => import("react/jsx-runtime").JSX.Element | "Loading...";
+export default CashValue;
+export declare enum EToolTipPosition {
+    TOP = "top",
+    BOTTOM = "bottom",
+    RIGHT = "right",
+    LEFT = "left"
+}

package/dist/lib/configs/awayzClient.d.ts

@@ -0,0 +1,2 @@
+import { QueryClient } from '@tanstack/react-query';
+export declare const awayzClient: QueryClient;

package/dist/lib/configs/awayzConfig.d.ts

@@ -0,0 +1,36 @@
+import { EAuthFlow } from '../types';
+export interface IAwayzConfig {
+    /**
+     * Your custom client ID from Awayz
+     */
+    clientId: string;
+    /**
+     * The authentication flow you want to use
+     */
+    authFlow: EAuthFlow;
+    /**
+     * The list of trusted origins for the postMessage flow
+     */
+    trustedOrigins: string[];
+    /**
+     * Enable test mode to use the Awayz components in a test environment
+     */
+    testMode?: boolean;
+    /**
+     * Enable non-chain hotels for hotel searches
+     * @default false
+     */
+    externalInventory?: boolean;
+    flightsConfig?: {
+        /**
+         * The maximum number of ping events before the flight search times out
+         * @default 3
+         */
+        streamTimeoutPingCount?: number;
+        /**
+         * The maximum time in seconds before the flight search times out
+         * @default 180
+         */
+        streamTimeoutTotalSeconds?: number;
+    };
+}

package/dist/lib/configs/baseUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const getBaseUrl: () => string;
+export declare const setBaseUrl: (testMode: boolean) => void;

package/dist/lib/configs/defaultAwayzConfig.d.ts

@@ -0,0 +1,8 @@
+export declare const defaultAwayzConfig: {
+    testMode: boolean;
+    externalInventory: boolean;
+    flightsConfig: {
+        streamTimeoutPingCount: number;
+        streamTimeoutTotalSeconds: number;
+    };
+};

package/dist/lib/configs/endpoints.d.ts

@@ -0,0 +1,26 @@
+export declare enum EAuthEndpoints {
+    SIGN_IN = "auth/user-login",
+    SIGN_UP = "auth/sign-up",
+    ME = "user",
+    RESEND_VERIFICATION_EMAIL = "auth/resend-verification-email",
+    UPDATE_USER_DETAILS = "account/update/user",
+    CONFIRM_EMAIL = "account/verifyAccount",
+    FORGOT_PASSWORD = "email/sendVeri",
+    RESEND_OTP = "email/sendForgotPasswordVerification",
+    RESET_PASSWORD = "account/updateUserPassword",
+    REQUEST_LIMIT = "user/request-limit",
+    APPLE_SOCIAL_SIGN_UP = "tp/apple/get/user",
+    GOOGLE_SOCIAL_SIGN_UP = "tp/google/get/user",
+    UPDATE_USER = "account/details/addUserDetails",
+    ACKNOWLEDGEMENT = "account/update/userAcknowledgement",
+    REGIONS = "user/region",
+    UPDATE_USER_REGION = "/account/update/userRegion",
+    UPDATE_PASSENGER_DETAILS = "/account/awayz",
+    EXCHANGE_TOKEN = "user/exchange-token",
+    REFRESH_TOKEN = "user/refresh-token",
+    OAUTH_INITIATE = "user/oauth2/initiate",
+    OAUTH_CALLBACK = "user/oauth2/callback"
+}
+export declare enum ECurrencyEndpoints {
+    CURRENCY_CONVERSION = "currency/convert"
+}

package/dist/lib/context/AwayzContext.d.ts

@@ -0,0 +1,17 @@
+import { IRegion, IResendVerificationEmailParams, IUser } from '../services/account/AccountServices.types';
+import { ISignInParams, ISignUpParams, TAuthResponse } from '../types/auth';
+import { IAwayzConfig } from '../configs/awayzConfig';
+export interface IAwayzContext {
+    config?: IAwayzConfig;
+    token?: string;
+    user?: IUser;
+    isAuthenticated: boolean;
+    isAuthenticating: boolean;
+    supportedRegions: IRegion[];
+    signIn: (params: ISignInParams) => Promise<TAuthResponse>;
+    signUp: (params: ISignUpParams) => Promise<TAuthResponse>;
+    signOut: () => void;
+    resendVerificationEmail: (params: IResendVerificationEmailParams) => Promise<boolean>;
+    setTokens: (accessToken: string, refreshToken: string) => void;
+}
+export declare const AwayzContext: import('react').Context<IAwayzContext>;

package/dist/lib/hooks/useAwayzAuth/useAwayzAuth.d.ts

@@ -0,0 +1,37 @@
+import { TEmbeddedAuthOptions } from './useAwayzAuth.types';
+import { IAuthData, IRegion, IResendVerificationEmailParams, IUser } from '../../services/account/AccountServices.types';
+import { ISignInParams, ISignUpParams } from '../../types/auth';
+declare enum ETokenType {
+    EXCHANGE = "exchange_token",
+    REFRESH = "refresh_token"
+}
+export declare const authFailurePostMessage: (action: ETokenType, error: any) => void;
+export declare const useAwayzAuth: (options: TEmbeddedAuthOptions) => {
+    isAuthenticating: boolean;
+    isAuthenticated: boolean;
+    token: string | undefined;
+    user: IUser | undefined;
+    supportedRegions: IRegion[];
+    signIn: (params: ISignInParams) => Promise<{
+        success: boolean;
+        data: IAuthData;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: any;
+        data?: undefined;
+    }>;
+    signUp: (params: ISignUpParams) => Promise<{
+        success: boolean;
+        data: IAuthData;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: any;
+        data?: undefined;
+    }>;
+    signOut: () => void;
+    resendVerificationEmail: (params: IResendVerificationEmailParams) => Promise<any>;
+    setTokens: (accessToken: string, refreshToken: string) => void;
+};
+export {};

package/dist/lib/hooks/useAwayzAuth/useAwayzAuth.types.d.ts

@@ -0,0 +1,17 @@
+import { IAuthData } from '../../services/account/AccountServices.types';
+import { EAuthFlow } from '../../types/EAuthFlow';
+interface IEmbeddedAuthOptionsBase {
+    authFlow: EAuthFlow;
+    trustedOrigins: string[];
+    includeDebugLogs?: boolean;
+}
+interface IEmbeddedAuthWithSyncSuccess extends IEmbeddedAuthOptionsBase {
+    onSuccess: (authData: IAuthData) => void;
+    onSuccessAsync?: never;
+}
+interface IEmbeddedAuthWithAsyncSuccess extends IEmbeddedAuthOptionsBase {
+    onSuccess?: never;
+    onSuccessAsync: (authData: IAuthData) => Promise<void>;
+}
+export type TEmbeddedAuthOptions = IEmbeddedAuthWithSyncSuccess | IEmbeddedAuthWithAsyncSuccess;
+export {};

package/dist/lib/hooks/useAwayzContext.d.ts

@@ -0,0 +1,2 @@
+import { IAwayzContext } from '../context/AwayzContext';
+export declare const useAwayzContext: () => IAwayzContext;

package/dist/lib/main.d.ts

@@ -0,0 +1,6 @@
+export * from './providers/AwayzProvider';
+export * from './hooks/useAwayzContext';
+export * from './types';
+export * from './services/instance';
+export * from './configs/awayzClient';
+export { getBaseUrl } from './configs/baseUrl';

package/dist/lib/providers/AwayzProvider.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { IAwayzConfig } from '../configs/awayzConfig';
+interface IAwayzProviderProps {
+    children: React.ReactNode;
+    config: IAwayzConfig;
+}
+/**
+ * In order for the Awayz components to work, you need to wrap your app with this provider.
+ * The Provider is responsible for initializing the authentication flow and providing the necessary context to the rest of the components.
+ */
+export declare const AwayzProvider: ({ children, config }: IAwayzProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,84 @@
+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
+     *
+     * @param refreshToken - The refresh token
+     */
+    refreshToken: (refreshToken: string) => Promise<TServiceResponse<{
+        user: IUser;
+        token: string;
+        id_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,152 @@
+import { ESearchLimitType } from '@type-op/shared';
+export interface ISignUpResponse {
+    success: boolean;
+    message: string;
+    user?: IUser;
+    token?: string;
+}
+/**
+ * @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 {
+    emailAddress: string;
+    password: string;
+    accountType: string;
+    priceId: string;
+    successUrl: string;
+    cancelUrl: string;
+    coupon?: string;
+    userRegion: string;
+    userSourceId?: 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 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 ISubscription {
+    tier: string;
+    flight_search_limit: number;
+    hotel_search_limit: number;
+    is_paid: 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;
+}