@kiva/kv-shop 2.1.2 → 3.0.1

package/dist/index.cjs

@@ -1,1227 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ShopError: () => ShopError,
-  VerificationState: () => VerificationState,
-  applyKivaCredit: () => applyKivaCredit,
-  applyPromoCredit: () => applyPromoCredit,
-  basketTotalsQuery: () => basketTotalsQuery,
-  callShopMutation: () => callShopMutation,
-  callShopQuery: () => callShopQuery,
-  checkSubscriptionStatus: () => checkSubscriptionStatus,
-  createBasket: () => createBasket,
-  defaultPaymentTypes: () => defaultPaymentTypes,
-  executeNewSubscriptionCheckout: () => executeNewSubscriptionCheckout,
-  executeOneTimeCheckout: () => executeOneTimeCheckout,
-  getBasketID: () => getBasketID,
-  getCheckoutStatus: () => getCheckoutStatus,
-  getCheckoutTrackingData: () => getCheckoutTrackingData,
-  getClientToken: () => getClientToken,
-  getFTDStatus: () => getFTDStatus,
-  getPromoFromBasket: () => getPromoFromBasket,
-  getReceiptItems: () => getReceiptItems,
-  getReceiptTotals: () => getReceiptTotals,
-  hasBasketExpired: () => hasBasketExpired,
-  isBasketVerified: () => isBasketVerified,
-  parseShopError: () => parseShopError,
-  pollForFinishedCheckout: () => pollForFinishedCheckout,
-  removeKivaCredit: () => removeKivaCredit,
-  removePromoCredit: () => removePromoCredit,
-  setBasketID: () => setBasketID,
-  setTipDonation: () => setTipDonation,
-  useBraintreeDropIn: () => useBraintreeDropIn,
-  validatePreCheckout: () => validatePreCheckout,
-  validatePreCheckoutMutation: () => validatePreCheckoutMutation,
-  watchBasketTotals: () => watchBasketTotals,
-  watchShopQuery: () => watchShopQuery
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/basket.ts
-var import_core = require("@apollo/client/core/core.cjs");
-
-// src/util/cookie.ts
-var getCookieValue = (name) => {
-  if (typeof document !== void 0) {
-    return decodeURIComponent(document.cookie.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`)?.pop() || "");
-  }
-};
-var setCookieValue = (name, value, options = "") => {
-  if (typeof document !== void 0) {
-    document.cookie = `${name}=${encodeURIComponent(value)};${options}`;
-  }
-};
-
-// src/shopError.ts
-var ShopError = class extends Error {
-  constructor({ code, original }, ...params) {
-    super(...params);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, ShopError);
-    }
-    this.name = "ShopError";
-    this.code = code;
-    this.original = original;
-  }
-  aggregateErrors(errors) {
-    this.errors = errors;
-  }
-};
-function parseShopError(error) {
-  if (error instanceof ShopError) {
-    return error;
-  }
-  const errorCode = error?.code ?? error?.extensions?.code ?? error?.name ?? "";
-  const errorMessage = typeof error === "string" ? error : error?.message ?? "";
-  if (errorCode === "invalidMethodParameter" && errorMessage.includes("paymentMethod.create")) {
-    return new ShopError({
-      code: "paymentMethod.create.invalidMethodParameter",
-      original: error
-    }, "There was a problem validating your payment information. Please double-check the details and try again.");
-  }
-  if (errorMessage.includes("Invalid request: ")) {
-    const finalError = errorMessage.split("Invalid request: ")[1].split("., ").map((e) => e.matchAll(/[A-Z_]+: (.*)/g))[0];
-    const finalCode = finalError[1];
-    const finalMessage = finalError[2];
-    return new ShopError({
-      code: `paymentMethod.${finalCode}`,
-      original: error
-    }, finalMessage);
-  }
-  if (errorCode === "insufficientFunds" || errorMessage.includes("There is not enough credit")) {
-    return new ShopError({
-      code: "shop.insufficientFunds",
-      original: error
-    }, "There is not enough money to complete the checkout. Please double-check the details and try again.");
-  }
-  if (errorCode === "shop.invalidBasketId" || errorCode === "shop.basketRequired" || errorCode === "shop.alreadyCheckedOut") {
-    return new ShopError({
-      code: errorCode,
-      original: error
-    }, "There was a problem with your basket. Please, refresh the page and try again.");
-  }
-  if (errorCode === "donationAmountTooLarge") {
-    return new ShopError({
-      code: errorCode,
-      original: error
-    }, errorMessage);
-  }
-  return new ShopError({
-    code: "shop.unknown",
-    original: error
-  }, "An unknown error occurred.");
-}
-
-// src/basket.ts
-function getBasketID() {
-  return getCookieValue("kvbskt");
-}
-function setBasketID(basketId) {
-  setCookieValue("kvbskt", basketId, "path=/;secure;");
-}
-async function createBasketHelper(apollo) {
-  try {
-    return apollo.mutate({
-      mutation: import_core.gql`mutation createNewBasketForUser { shop { id createBasket } }`
-    }).then(({ data }) => {
-      const newBasketId = data.shop?.createBasket ?? null;
-      if (newBasketId) {
-        setBasketID(newBasketId);
-      }
-    });
-  } catch (error) {
-    throw parseShopError(error);
-  }
-}
-var activeBasketCreationQuery = null;
-async function createBasket(apollo) {
-  if (activeBasketCreationQuery) {
-    return activeBasketCreationQuery;
-  }
-  activeBasketCreationQuery = createBasketHelper(apollo);
-  return activeBasketCreationQuery;
-}
-function hasBasketExpired(error) {
-  const errorCode = error?.code ?? error?.extensions?.code ?? error?.name ?? "";
-  return ["shop.invalidBasketId", "shop.basketRequired", "shop.alreadyCheckedOut"].includes(errorCode);
-}
-
-// src/basketCredits.ts
-var import_core2 = require("@apollo/client/core/core.cjs");
-
-// src/shopQueries.ts
-var watchQueries = /* @__PURE__ */ new Set();
-async function callShopMutation(apollo, options, maxretries = 2) {
-  try {
-    const result = await apollo.mutate({
-      ...options,
-      variables: {
-        ...options.variables,
-        basketId: getBasketID()
-      },
-      refetchQueries: options.awaitRefetchQueries ? Array.from(watchQueries) : []
-    });
-    if (result?.errors?.length) {
-      const basketErrors = result?.errors.filter((err) => hasBasketExpired(err));
-      if (basketErrors.length) {
-        if (maxretries > 0) {
-          await createBasket(apollo);
-          return callShopMutation(apollo, options, maxretries - 1);
-        }
-        throw basketErrors[0];
-      }
-      if (result?.errors?.length) {
-        throw result.errors[0];
-      }
-    }
-    return result?.data;
-  } catch (e) {
-    throw parseShopError(e);
-  }
-}
-async function callShopQuery(apollo, options, maxretries = 2) {
-  try {
-    const result = await apollo.query({
-      ...options,
-      variables: {
-        ...options.variables,
-        basketId: getBasketID()
-      }
-    });
-    if (result?.errors?.length) {
-      const basketErrors = result?.errors.filter((err) => hasBasketExpired(err));
-      if (basketErrors.length) {
-        if (maxretries > 0) {
-          await createBasket(apollo);
-          return callShopQuery(apollo, options, maxretries - 1);
-        }
-        throw basketErrors[0];
-      }
-      if (result?.errors?.length) {
-        throw result.errors[0];
-      }
-    }
-    return result?.data;
-  } catch (e) {
-    throw parseShopError(e);
-  }
-}
-function watchShopQuery(apollo, options, maxretries = 2) {
-  let retries = 0;
-  watchQueries.add(options.query);
-  const observable = apollo.watchQuery({
-    ...options,
-    variables: {
-      ...options.variables,
-      basketId: getBasketID()
-    }
-  });
-  const oldSubscribe = observable.subscribe.bind(observable);
-  observable.subscribe = (...args) => {
-    let nextFn;
-    let errorFn;
-    let completeFn;
-    if (typeof args[0] === "function") {
-      [nextFn, errorFn, completeFn] = args;
-    } else {
-      nextFn = args[0]?.next;
-      errorFn = args[0]?.error;
-      completeFn = args[0]?.complete;
-    }
-    const newErrorFn = (err) => {
-      const basketErrors = err?.graphQLErrors?.filter((e) => hasBasketExpired(e));
-      if (basketErrors.length) {
-        if (retries < maxretries) {
-          createBasket(apollo).then(() => {
-            retries += 1;
-            observable.refetch({
-              ...observable.variables,
-              basketId: getBasketID()
-            });
-          });
-        } else {
-          errorFn(parseShopError(basketErrors[0]));
-        }
-      } else {
-        if (err?.graphQLErrors?.length) {
-          errorFn(parseShopError(err.graphQLErrors[0]));
-        }
-        if (err?.networkError) {
-          errorFn(parseShopError(err.networkError));
-        }
-      }
-    };
-    return oldSubscribe(nextFn, newErrorFn, completeFn);
-  };
-  return observable;
-}
-
-// src/basketCredits.ts
-async function applyKivaCredit(apollo) {
-  const data = await callShopMutation(apollo, {
-    awaitRefetchQueries: true,
-    mutation: import_core2.gql`mutation applyKivaCredit($basketId: String) {
-			shop (basketId: $basketId) {
-				id
-				addCreditByType(creditType: kiva_credit)
-			}
-		}`
-  });
-  return !!data?.shop?.addCreditByType;
-}
-async function removeKivaCredit(apollo) {
-  const data = await callShopMutation(apollo, {
-    awaitRefetchQueries: true,
-    mutation: import_core2.gql`mutation removeKivaCredit($basketId: String) {
-			shop (basketId: $basketId) {
-				id
-				removeCreditByType(creditType: kiva_credit)
-			}
-		}`
-  });
-  return !!data?.shop?.removeCreditByType;
-}
-async function applyPromoCredit(apollo, options) {
-  if (!options?.variables?.creditType || !options?.variables?.redemptionCode) {
-    return Promise.resolve({
-      errors: [
-        {
-          message: "Missing required parameter.",
-          extensions: { code: "upc.missing_parameter" }
-        }
-      ]
-    });
-  }
-  const data = await callShopMutation(apollo, {
-    awaitRefetchQueries: true,
-    fetchPolicy: options?.fetchPolicy ?? "network-only",
-    mutation: import_core2.gql`mutation applyPromoCredit(
-			$basketId: String,
-			$creditType: CreditTypeEnum!,
-			$redemptionCode: String
-		) {
-			shop (basketId: $basketId) {
-				id
-				addCreditByType(creditType: $creditType, redemptionCode: $redemptionCode)
-			}
-		}`,
-    variables: { ...options?.variables }
-  });
-  return data;
-}
-async function removePromoCredit(apollo, options) {
-  if (!options?.variables?.creditType && !options?.variables?.redemptionCode) {
-    return Promise.resolve(false);
-  }
-  const data = await callShopMutation(apollo, {
-    awaitRefetchQueries: true,
-    fetchPolicy: options?.fetchPolicy ?? "network-only",
-    mutation: import_core2.gql`mutation removePromoCredit(
-			$basketId: String,
-			$creditType: CreditTypeEnum!,
-			$redemptionCode: String
-		) {
-			shop (basketId: $basketId) {
-				id
-				removeCreditByType(creditType: $creditType, redemptionCode: $redemptionCode)
-			}
-		}`,
-    variables: { ...options?.variables }
-  });
-  return !!data?.shop?.removeCreditByType;
-}
-
-// src/basketItems.ts
-var import_core3 = require("@apollo/client/core/core.cjs");
-var import_numeral = __toESM(require("numeral"), 1);
-async function setTipDonation({ amount, apollo, metadata }) {
-  const donationAmount = (0, import_numeral.default)(amount).format("0.00");
-  const data = await callShopMutation(apollo, {
-    awaitRefetchQueries: true,
-    mutation: import_core3.gql`mutation setTipDonation($price: Money!, $basketId: String, $metadata: String) {
-			shop (basketId: $basketId) {
-				id
-				updateDonation (donation: {
-					price: $price,
-					isTip: true,
-					metadata: $metadata,
-				})
-				{
-					id
-					price
-					isTip
-				}
-			}
-		}`,
-    variables: { price: donationAmount, metadata }
-  });
-  return data?.shop?.updateDonation;
-}
-
-// src/basketTotals.ts
-var import_core4 = require("@apollo/client/core/core.cjs");
-var basketTotalsQuery = import_core4.gql`query basketTotals($basketId: String) {
-	shop (basketId: $basketId) {
-		id
-		basket {
-			id
-			totals {
-				bonusAppliedTotal
-				bonusAvailableTotal
-				creditAmountNeeded
-				creditAppliedTotal
-				creditAvailableTotal
-				donationTotal
-				itemTotal
-				freeTrialAppliedTotal
-				freeTrialAvailableTotal
-				loanReservationTotal
-				kivaCardTotal
-				kivaCreditAppliedTotal
-				kivaCreditAvailableTotal
-				kivaCreditRemaining
-				kivaCreditToReapply
-				redemptionCodeAppliedTotal
-				redemptionCodeAvailableTotal
-				universalCodeAppliedTotal
-				universalCodeAvailableTotal
-			}
-		}
-	}
-}`;
-function watchBasketTotals(apollo) {
-  return watchShopQuery(apollo, {
-    query: basketTotalsQuery
-  });
-}
-
-// src/basketVerification.ts
-var VerificationState = /* @__PURE__ */ ((VerificationState2) => {
-  VerificationState2["VERIFIED"] = "verified";
-  VerificationState2["PENDING"] = "pending";
-  VerificationState2["REQUIRED"] = "required";
-  VerificationState2["MAY_BE_NEEDED"] = "may_be_needed";
-  VerificationState2["NOT_NEEDED"] = "not_needed";
-  return VerificationState2;
-})(VerificationState || {});
-function isBasketVerified(state) {
-  return state === "verified" /* VERIFIED */ || state === "not_needed" /* NOT_NEEDED */;
-}
-
-// src/checkoutStatus.ts
-var import_core5 = require("@apollo/client/core/core.cjs");
-
-// src/util/poll.ts
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function poll(fn, fnCondition, interval, timeout) {
-  const endTime = Date.now() + timeout;
-  let result = await fn();
-  while (!fnCondition(result)) {
-    if (Date.now() > endTime) {
-      throw new Error("Polling timed out");
-    }
-    await wait(interval);
-    result = await fn();
-  }
-  return result;
-}
-
-// src/util/visitorId.ts
-function getVisitorID() {
-  return getCookieValue("uiv");
-}
-
-// src/checkoutStatus.ts
-async function getCheckoutStatus({ apollo, transactionSagaId }) {
-  return apollo.query({
-    query: import_core5.gql`
-			query checkoutStatus($transactionId: String!, $visitorId: String) {
-				checkoutStatus(transactionId: $transactionId, visitorId: $visitorId) {
-					basketId
-					errorCode
-					errorMessage
-					receipt {
-						checkoutId
-					}
-					requestedAt
-					status
-					transactionId
-					updatedAt
-				}
-			}
-		`,
-    variables: {
-      transactionId: transactionSagaId,
-      visitorId: getVisitorID()
-    },
-    fetchPolicy: "network-only"
-  });
-}
-async function pollForFinishedCheckout({
-  apollo,
-  transactionSagaId,
-  interval = 1e3,
-  timeout = 6e4
-}) {
-  return poll(
-    // function to poll
-    () => getCheckoutStatus({
-      apollo,
-      transactionSagaId
-    }),
-    // function to check for completed status
-    (result) => {
-      const { status, errorCode, errorMessage } = result?.data?.checkoutStatus;
-      if (status === "COMPLETED" || errorCode || errorMessage) {
-        return true;
-      }
-      return false;
-    },
-    interval,
-    timeout
-  );
-}
-
-// src/managedAccount.ts
-var import_core6 = require("@apollo/client/core/core.cjs");
-async function getPromoFromBasket(apollo, options) {
-  if (!options?.variables?.promoFundId && !options?.variables?.basketId) {
-    return Promise.resolve({ error: "promoFundId or basketId variable required" });
-  }
-  const data = await callShopQuery(apollo, {
-    variables: { ...options?.variables },
-    query: import_core6.gql`
-			query promoCampaign($basketId: String, $promoFundId: String) {
-				shop (basketId: $basketId) {
-					id
-					promoCampaign (promoFundId: $promoFundId) {
-						promoFund {
-							id
-							displayName
-							displayDescription
-							promoPrice
-						}
-						promoGroup {
-							id
-							type
-							teamId
-						}
-						managedAccount {
-							managementType
-							audience
-							allowDonations
-							sendKivaNewsletter
-							id
-							isEmployee
-							formId
-							pageId
-							loanSearchCriteria {
-								filters {
-									cityState
-									country
-									currencyLossPossible
-									dafEligible
-									distributionModel
-									status
-									excludeNonRated
-									expiringSoon
-									gender
-									hasResearchScore
-									isGroup
-									lenderFavorite
-									loanLimit
-									isMatched
-									sector
-									loanTags
-									theme
-								}
-								sortBy
-							}
-						}
-					}
-				}
-			}
-		`,
-    fetchPolicy: options?.fetchPolicy ?? "network-only"
-  }, 0);
-  return data;
-}
-
-// src/oneTimeCheckout.ts
-var import_core9 = require("@apollo/client/core/core.cjs");
-var import_kv_analytics = require("@kiva/kv-analytics");
-var import_numeral2 = __toESM(require("numeral"), 1);
-
-// src/validatePreCheckout.ts
-var import_core7 = require("@apollo/client/core/core.cjs");
-var validatePreCheckoutMutation = import_core7.gql`
-	mutation validatePreCheckout(
-		$basketId: String,
-		$email: String,
-		$visitorId: String,
-		$emailOptIn: Boolean,
-		$inviter: InviterInput
-	) {
-	shop (basketId: $basketId) {
-		id
-		validatePreCheckout (email: $email, visitorId: $visitorId, emailOptIn: $emailOptIn, inviter: $inviter) {
-			error
-			success
-			value
-		}
-	}
-}`;
-async function validatePreCheckout({
-  apollo,
-  emailAddress,
-  emailOptIn,
-  valetInviter
-}) {
-  const data = await callShopMutation(apollo, {
-    mutation: validatePreCheckoutMutation,
-    variables: {
-      visitorId: getVisitorID(),
-      email: emailAddress,
-      emailOptIn,
-      inviter: valetInviter
-    }
-  }, 0);
-  const results = data?.shop?.validatePreCheckout;
-  const errors = results.filter(({ success }) => !success).map((result) => parseShopError(result));
-  if (errors.length) {
-    const aggregate = new ShopError({ code: "shop.failedCheckoutValidation" });
-    aggregate.aggregateErrors(errors);
-    throw aggregate;
-  }
-}
-
-// src/util/redirect.ts
-function redirectTo(href) {
-  return new Promise(() => {
-    window.location.href = href;
-  });
-}
-
-// src/receipt.ts
-var import_core8 = require("@apollo/client/core/core.cjs");
-async function getFTDStatus(apollo) {
-  const result = await apollo.query({
-    query: import_core8.gql`
-			query ftdStatus {
-				my {
-					id
-					userAccount {
-						id
-						isFirstTimeDepositor
-					}
-				}
-			}
-		`
-  });
-  return result.data?.my?.userAccount?.isFirstTimeDepositor ?? false;
-}
-async function getReceiptItems(apollo, checkoutId) {
-  return new Promise((resolve, reject) => {
-    const limit = 100;
-    let offset = 0;
-    const observer = apollo.watchQuery({
-      query: import_core8.gql`
-				query receiptItems($checkoutId: Int, $visitorId: String, $limit: Int, $offset: Int) {
-					shop {
-						id
-						receipt(checkoutId: $checkoutId, visitorId: $visitorId) {
-							id
-							items(limit: $limit, offset: $offset) {
-								totalCount
-								values {
-									id
-									price
-									__typename
-
-									... on Donation {
-										id
-										isTip
-										isUserEdited
-									}
-								}
-							}
-						}
-					}
-				}
-			`,
-      variables: {
-        checkoutId,
-        visitorId: getVisitorID(),
-        limit,
-        offset
-      }
-    });
-    let items = [];
-    const handleResult = async (result) => {
-      const total = result.data?.shop?.receipt?.items?.totalCount;
-      items = items.concat(result.data?.shop?.receipt?.items?.values);
-      if (total > offset + limit) {
-        offset += limit;
-        const nextResult = await observer.fetchMore({
-          variables: {
-            offset
-          }
-        });
-        try {
-          handleResult(nextResult);
-        } catch (e) {
-          reject(e);
-        }
-      } else {
-        resolve(items);
-      }
-    };
-    observer.subscribe({
-      next: handleResult,
-      error: (error) => {
-        reject(error);
-      }
-    });
-  });
-}
-async function getReceiptTotals(apollo, checkoutId) {
-  const result = await apollo.query({
-    query: import_core8.gql`
-			query receiptTotals($checkoutId: Int, $visitorId: String) {
-				shop {
-					id
-					receipt(checkoutId: $checkoutId, visitorId: $visitorId) {
-						id
-						totals {
-							loanReservationTotal
-							donationTotal
-							kivaCardTotal
-							itemTotal
-							kivaCreditAppliedTotal
-							depositTotals {
-								depositTotal
-							}
-						}
-					}
-				}
-			}
-		`,
-    variables: {
-      checkoutId,
-      visitorId: getVisitorID()
-    }
-  });
-  return result.data?.shop?.receipt?.totals;
-}
-async function getCheckoutTrackingData(apollo, checkoutId, paymentType) {
-  const checkoutIdInt = parseInt(checkoutId, 10);
-  const [isFTD, items, totals] = await Promise.all([
-    getFTDStatus(apollo),
-    getReceiptItems(apollo, checkoutIdInt),
-    getReceiptTotals(apollo, checkoutIdInt)
-  ]);
-  const loans = items.filter((item) => item.__typename === "LoanReservation");
-  const donations = items.filter((item) => item.__typename === "Donation");
-  const kivaCards = items.filter((item) => item.__typename === "KivaCard");
-  return {
-    transactionId: checkoutId,
-    itemTotal: totals.itemTotal,
-    // Loan reservations
-    loans,
-    loanCount: loans.length,
-    loanTotal: totals.loanReservationTotal,
-    // Donations
-    donations: donations.map(({ id, price, __typename }) => ({ id, price, __typename })),
-    donationTotal: totals.donationTotal,
-    isTip: donations.every((donation) => donation.isTip),
-    isUserEdited: donations.some((donation) => donation.isUserEdited),
-    // Kiva Cards
-    kivaCards,
-    kivaCardCount: kivaCards.length,
-    kivaCardTotal: totals.kivaCardTotal,
-    // Credit & deposit
-    kivaCreditAppliedTotal: totals.kivaCreditAppliedTotal,
-    depositTotal: totals.depositTotals?.depositTotal ?? "0.00",
-    paymentType,
-    isFTD
-  };
-}
-
-// src/oneTimeCheckout.ts
-async function creditAmountNeeded(apollo) {
-  const data = await callShopQuery(apollo, {
-    query: import_core9.gql`
-			query creditAmountNeeded($basketId: String) {
-				shop (basketId: $basketId) {
-					id
-					basket {
-						id
-						totals {
-							creditAmountNeeded
-						}
-					}
-				}
-			}
-		`,
-    fetchPolicy: "network-only"
-  }, 0);
-  return data?.shop?.basket?.totals?.creditAmountNeeded;
-}
-var creditCheckoutMutation = import_core9.gql`
-	mutation creditCheckout(
-		$basketId: String,
-		$visitorId: String
-	) {
-		shop (basketId: $basketId) {
-			id
-			transactionId: checkoutAsync (visitorId: $visitorId)
-		}
-	}
-`;
-var depositCheckoutMutation = import_core9.gql`
-	mutation depositCheckout(
-		$basketId: String,
-		$amount: Money!,
-		$nonce: String!,
-		$savePaymentMethod: Boolean,
-		$deviceData: String,
-		$visitorId: String
-	) {
-		shop (basketId: $basketId) {
-			id
-			transactionId: doNoncePaymentDepositAndCheckoutAsync(
-				amount: $amount,
-				nonce: $nonce,
-				savePaymentMethod: $savePaymentMethod,
-				deviceData: $deviceData,
-				visitorId: $visitorId
-			)
-		}
-	}
-`;
-function creditCheckout(apollo) {
-  return callShopMutation(apollo, {
-    mutation: creditCheckoutMutation,
-    variables: {
-      visitorId: getVisitorID()
-    }
-  }, 0);
-}
-async function depositCheckout({
-  apollo,
-  braintree,
-  amount
-}) {
-  try {
-    const paymentMethod = await braintree.requestPaymentMethod();
-    if (!paymentMethod) {
-      throw new ShopError(
-        { code: "shop.dropinNoPaymentMethod" },
-        "No payment method returned from braintree dropin"
-      );
-    }
-    const { nonce, deviceData, type } = paymentMethod;
-    return {
-      paymentType: type,
-      mutation: callShopMutation(apollo, {
-        mutation: depositCheckoutMutation,
-        variables: {
-          nonce,
-          amount,
-          savePaymentMethod: false,
-          // save payment methods handled by braintree drop in UI
-          deviceData,
-          visitorId: getVisitorID()
-        }
-      }, 0)
-    };
-  } catch (e) {
-    throw parseShopError(e);
-  }
-}
-async function trackSuccess(apollo, checkoutId, paymentType) {
-  try {
-    const transactionData = await getCheckoutTrackingData(
-      apollo,
-      checkoutId,
-      paymentType
-    );
-    (0, import_kv_analytics.trackTransaction)(transactionData);
-    await wait(800);
-  } catch (e) {
-    console.error("Error tracking transaction", e);
-  }
-}
-async function executeOneTimeCheckout({
-  apollo,
-  braintree,
-  emailAddress,
-  emailOptIn,
-  valetInviter,
-  deactivateRedirect
-}) {
-  await validatePreCheckout({
-    apollo,
-    emailAddress,
-    emailOptIn,
-    valetInviter
-  });
-  const creditNeeded = await creditAmountNeeded(apollo);
-  const creditRequired = (0, import_numeral2.default)(creditNeeded).value() > 0;
-  if (creditRequired && !braintree) {
-    throw new ShopError({ code: "shop.dropinRequired" }, "Braintree dropin required for credit deposit checkout");
-  }
-  let data;
-  let paymentType = "";
-  if (creditRequired) {
-    const checkoutResult = await depositCheckout({
-      apollo,
-      braintree,
-      amount: creditNeeded
-    });
-    paymentType = checkoutResult.paymentType;
-    data = await checkoutResult.mutation;
-  } else {
-    data = await creditCheckout(apollo);
-  }
-  const transactionId = data?.shop?.transactionId;
-  const result = await pollForFinishedCheckout({
-    apollo,
-    transactionSagaId: transactionId,
-    timeout: 3e5
-    // five minutes
-  });
-  if (result.errors?.length) {
-    throw parseShopError(result.errors[0]);
-  }
-  const checkoutId = result.data?.checkoutStatus?.receipt?.checkoutId;
-  await trackSuccess(apollo, checkoutId, paymentType);
-  if (deactivateRedirect) {
-    return result;
-  }
-  let redirectUrl = `/checkout/post-purchase?kiva_transaction_id=${checkoutId}`;
-  if (valetInviter?.inviterId) {
-    redirectUrl += `&valet_inviter=${valetInviter.inviterId}`;
-  }
-  await redirectTo(redirectUrl);
-}
-
-// src/subscriptionCheckout.ts
-var import_core10 = require("@apollo/client/core/core.cjs");
-async function checkSubscriptionStatus(apollo) {
-  const { data: subsData } = await apollo.query({
-    query: import_core10.gql`query subscriptionStatus{
-			my {
-				id
-				subscriptions {
-					totalCount
-				}
-				autoDeposit {
-					id
-					isSubscriber
-				}
-			}
-		}`
-  });
-  if (!subsData?.my?.id) {
-    throw new ShopError({ code: "api.authenticationRequired" }, "You must be logged in to continue.");
-  }
-  if ((subsData?.my?.subscriptions?.totalCount ?? 0) > 0 || subsData?.my?.autoDeposit?.isSubscriber) {
-    throw new ShopError({ code: "shop.subscriptionExists" }, "You already have an existing Monthly Good subscription. Changes can be made in your subscription settings.");
-  }
-  if (subsData?.my?.autoDeposit?.id) {
-    throw new ShopError({ code: "shop.autoDepositExists" }, "You already have existing Auto Deposit settings. Changes can be made in your subscription settings.");
-  }
-  return true;
-}
-async function executeNewSubscriptionCheckout({
-  amount,
-  apollo,
-  dayOfMonth = (/* @__PURE__ */ new Date()).getDate(),
-  donateAmount,
-  paymentMethod
-}) {
-  const amountRegex = new RegExp(/^\d+\.\d{2}$/);
-  if (!amountRegex.test(amount) || !amountRegex.test(donateAmount)) {
-    throw new ShopError({
-      code: "api.invalidMethodParameter"
-    }, "Please check that the amount is correct and try again.");
-  }
-  await checkSubscriptionStatus(apollo);
-  const { deviceData, nonce } = paymentMethod;
-  let data;
-  let error;
-  try {
-    const result = await apollo.mutate({
-      variables: {
-        nonce,
-        deviceData,
-        amount,
-        donateAmount,
-        dayOfMonth
-      },
-      mutation: import_core10.gql`mutation createAutoDepositSubscription(
-				$nonce: String!,
-				$deviceData: String,
-				$amount: Money!,
-				$donateAmount: Money!,
-				$dayOfMonth: Int!
-			) {
-				my {
-					createAutoDeposit (
-						autoDeposit: {
-							amount: $amount,
-							donateAmount: $donateAmount,
-							dayOfMonth: $dayOfMonth,
-						},
-						deviceData: $deviceData,
-						paymentMethodNonce: $nonce
-					) {
-						id amount donateAmount dayOfMonth status
-					}
-				}
-			}`
-    });
-    if (result?.error || result?.errors?.length) {
-      error = result?.error ?? result?.errors?.[0];
-    } else {
-      data = result?.data;
-    }
-  } catch (e) {
-    error = e;
-  }
-  if (error) {
-    const parsed = parseShopError(error);
-    if (parsed?.code === "shop.unknown") {
-      throw new ShopError({
-        code: "shop.createAutoDepositError",
-        original: parsed
-      }, "There was a problem trying to setup your monthly deposit.");
-    }
-    throw parsed;
-  }
-  return data?.my?.createAutoDeposit;
-}
-
-// src/useBraintreeDropIn.ts
-var import_core11 = require("@apollo/client/core/core.cjs");
-var import_numeral3 = __toESM(require("numeral"), 1);
-var import_vue_demi = require("vue-demi");
-var defaultPaymentTypes = ["paypal", "card", "applePay", "googlePay"];
-async function getClientToken(apollo) {
-  const { data, error, errors } = await apollo.query({
-    query: import_core11.gql`query getClientToken {
-			shop {
-				id
-				getClientToken(useCustomerId: true)
-			}
-		}`
-  });
-  if (error || errors?.length) {
-    throw parseShopError(error ?? errors?.[0]);
-  }
-  return data?.shop?.getClientToken;
-}
-function initBraintreeDropin() {
-  let instance;
-  let formattedAmount = "";
-  const paymentMethodRequestable = (0, import_vue_demi.ref)(false);
-  function getApplePaymentRequest(amount) {
-    return {
-      countryCode: "US",
-      currencyCode: "USD",
-      // merchantCapabilities: ['supports3DS'], // TODO: confirm/update
-      requiredBillingContactFields: ["postalAddress"],
-      // supportedNetworks: ['amex', 'discover', 'interac', 'jcb', 'masterCard', 'visa'], // TODO: confirm/update
-      total: {
-        label: "Kiva",
-        amount
-      }
-    };
-  }
-  function getGoogleTransactionInfo(amount) {
-    return {
-      totalPriceStatus: "FINAL",
-      totalPrice: amount,
-      currencyCode: "USD",
-      countryCode: "US"
-    };
-  }
-  function initDropInActions() {
-    if (instance.isPaymentMethodRequestable()) {
-      paymentMethodRequestable.value = true;
-    }
-    instance.on("paymentMethodRequestable", (event) => {
-      paymentMethodRequestable.value = true;
-    });
-    instance.on("noPaymentMethodRequestable", () => {
-      paymentMethodRequestable.value = false;
-    });
-  }
-  async function initDropIn({
-    amount,
-    authToken,
-    container,
-    googlePayMerchantId,
-    paymentTypes = [...defaultPaymentTypes],
-    preselectVaultedPaymentMethod = true,
-    paypalFlow = "checkout"
-  }) {
-    formattedAmount = (0, import_numeral3.default)(amount).format("0.00");
-    const { default: DropIn } = await import("braintree-web-drop-in");
-    try {
-      instance = await DropIn.create({
-        authorization: authToken,
-        container,
-        dataCollector: {
-          kount: true
-          // Required if Kount fraud data collection is enabled
-        },
-        // vaultManager: true, - Useful for testing and removing payment methods easily.
-        paymentOptionPriority: paymentTypes,
-        preselectVaultedPaymentMethod,
-        card: {
-          vault: {
-            allowVaultCardOverride: true
-          }
-        },
-        paypal: {
-          flow: paypalFlow,
-          amount: formattedAmount,
-          currency: "USD",
-          buttonStyle: {
-            // @ts-ignore
-            color: "gold",
-            // @ts-ignore
-            shape: "rect",
-            // @ts-ignore
-            size: "responsive"
-          }
-        },
-        googlePay: {
-          googlePayVersion: 2,
-          merchantId: googlePayMerchantId,
-          transactionInfo: getGoogleTransactionInfo(formattedAmount),
-          button: {
-            allowedPaymentMethods: [{
-              type: "CARD",
-              // @ts-ignore
-              parameters: {
-                // allowedAuthMethods: ['PAN_ONLY', 'CRYPTOGRAM_3DS'], // TODO: confirm/update
-                // allowedCardNetworks: ['AMEX', 'DISCOVER', 'INTERAC', 'JCB', 'MASTERCARD', 'VISA'], // TODO: confirm/update
-                billingAddressRequired: true,
-                billingAddressParameters: {
-                  format: "FULL"
-                }
-              }
-            }]
-          }
-        },
-        applePay: {
-          displayName: "Kiva",
-          paymentRequest: getApplePaymentRequest(formattedAmount)
-        }
-      });
-      initDropInActions();
-    } catch (e) {
-      throw new ShopError({
-        code: "shop.braintreeDropinInitError",
-        original: e
-      }, "An Error has occured. Please refresh the page and try again.");
-    }
-    return instance;
-  }
-  async function requestPaymentMethod() {
-    if (instance.isPaymentMethodRequestable()) {
-      return instance.requestPaymentMethod();
-    }
-  }
-  function updateAmount(amount) {
-    const newAmount = (0, import_numeral3.default)(amount).format("0.00");
-    if (newAmount !== formattedAmount) {
-      formattedAmount = newAmount;
-      instance?.updateConfiguration("paypal", "amount", formattedAmount);
-      instance?.updateConfiguration("googlePay", "transactionInfo", getGoogleTransactionInfo(formattedAmount));
-      instance?.updateConfiguration?.("applePay", "paymentRequest", getApplePaymentRequest(formattedAmount));
-    }
-  }
-  return {
-    initDropIn,
-    paymentMethodRequestable,
-    requestPaymentMethod,
-    updateAmount
-  };
-}
-var instances = {};
-function useBraintreeDropIn(key = "default") {
-  if (!instances[key]) {
-    instances[key] = initBraintreeDropin();
-  }
-  return instances[key];
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ShopError,
-  VerificationState,
-  applyKivaCredit,
-  applyPromoCredit,
-  basketTotalsQuery,
-  callShopMutation,
-  callShopQuery,
-  checkSubscriptionStatus,
-  createBasket,
-  defaultPaymentTypes,
-  executeNewSubscriptionCheckout,
-  executeOneTimeCheckout,
-  getBasketID,
-  getCheckoutStatus,
-  getCheckoutTrackingData,
-  getClientToken,
-  getFTDStatus,
-  getPromoFromBasket,
-  getReceiptItems,
-  getReceiptTotals,
-  hasBasketExpired,
-  isBasketVerified,
-  parseShopError,
-  pollForFinishedCheckout,
-  removeKivaCredit,
-  removePromoCredit,
-  setBasketID,
-  setTipDonation,
-  useBraintreeDropIn,
-  validatePreCheckout,
-  validatePreCheckoutMutation,
-  watchBasketTotals,
-  watchShopQuery
-});