@kiva/kv-shop 1.1.3 → 1.1.4

package/dist/index.cjs

@@ -0,0 +1,411 @@
+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,
+  checkSubscriptionStatus: () => checkSubscriptionStatus,
+  defaultPaymentTypes: () => defaultPaymentTypes,
+  executeNewSubscriptionCheckout: () => executeNewSubscriptionCheckout,
+  executeOneTimeCheckout: () => executeOneTimeCheckout,
+  getBasketID: () => getBasketID,
+  getClientToken: () => getClientToken,
+  getCookieValue: () => getCookieValue,
+  parseShopError: () => parseShopError,
+  setBasketID: () => setBasketID,
+  setTipDonation: () => setTipDonation,
+  useBraintreeDropIn: () => useBraintreeDropIn,
+  waitOnTransaction: () => waitOnTransaction
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/basket.ts
+var getCookieValue = (name) => {
+  if (typeof document !== void 0) {
+    return decodeURIComponent(document.cookie.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`)?.pop() || "");
+  }
+};
+function getBasketID() {
+  return getCookieValue("kvbskt");
+}
+function setBasketID(basketId) {
+}
+
+// src/basketItems.ts
+var import_core = require("@apollo/client/core");
+var import_numeral = __toESM(require("numeral"), 1);
+
+// 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;
+  }
+};
+function parseShopError(error) {
+  const errorCode = error?.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.");
+  }
+  return new ShopError({
+    code: "shop.unknown",
+    original: error
+  }, "An unknown error occurred.");
+}
+
+// src/basketItems.ts
+async function setTipDonation({ amount, apollo }) {
+  let data;
+  let error;
+  try {
+    const result = await apollo.mutate({
+      mutation: import_core.gql`mutation setTipDonation($price: Money!, $basketId: String) {
+				shop (basketId: $basketId) {
+					id
+					updateDonation (donation: {
+						price: $price,
+						isTip: true
+					})
+					{
+						id
+						price
+						isTip
+					}
+				}
+			}`,
+      variables: {
+        price: (0, import_numeral.default)(amount).format("0.00"),
+        basketId: getBasketID()
+      }
+    });
+    if (result.error || result.errors.length) {
+      error = result.error ?? result.errors[0];
+    } else {
+      data = result.data;
+    }
+  } catch (e) {
+    error = e;
+  }
+  if (error) {
+    throw parseShopError(error);
+  }
+  return data?.shop?.updateDonation;
+}
+
+// src/oneTimeCheckout.ts
+var import_core2 = require("@apollo/client/core");
+async function executeOneTimeCheckout({ apollo }) {
+}
+async function waitOnTransaction({ apollo, transactionId }) {
+  const result = await apollo.query({
+    query: import_core2.gql`
+			query checkoutStatus($transactionId: String!, $visitorId: string) {
+				checkoutStatus(transactionId: $transactionId, visitorId: $visitorId) {
+					errorCode
+					errorMessage
+					status
+					transactionId
+				}
+			}
+		`,
+    variables: {
+      transactionId
+    }
+  });
+}
+
+// src/subscriptionCheckout.ts
+var import_core3 = require("@apollo/client/core");
+async function checkSubscriptionStatus(apollo) {
+  const { data: subsData } = await apollo.query({
+    query: import_core3.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.query({
+      variables: {
+        dayOfMonth,
+        deviceData,
+        nonce
+      },
+      query: import_core3.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_core4 = require("@apollo/client/core");
+var import_numeral2 = __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_core4.gql`query getClientToken {
+			shop {
+				id
+				getClientToken(useCustomerId: true)
+			}
+		}`
+  });
+  if (error || errors.length) {
+    throw parseShopError(error ?? errors[0]);
+  }
+  return data?.shop?.getClientToken;
+}
+function useBraintreeDropIn() {
+  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_numeral2.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_numeral2.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ShopError,
+  checkSubscriptionStatus,
+  defaultPaymentTypes,
+  executeNewSubscriptionCheckout,
+  executeOneTimeCheckout,
+  getBasketID,
+  getClientToken,
+  getCookieValue,
+  parseShopError,
+  setBasketID,
+  setTipDonation,
+  useBraintreeDropIn,
+  waitOnTransaction
+});

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { getBasketID, getCookieValue, setBasketID } from './basket.js';
+export { SetTipDonationOptions, setTipDonation } from './basketItems.js';
+export { OneTimeCheckoutOptions, WaitOnTransactionOptions, executeOneTimeCheckout, waitOnTransaction } from './oneTimeCheckout.js';
+export { ShopError, ShopErrorOptions, parseShopError } from './shopError.js';
+export { SubscriptionCheckoutOptions, checkSubscriptionStatus, executeNewSubscriptionCheckout } from './subscriptionCheckout.js';
+export { DropInInitOptions, PayPalFlowType, PaymentType, defaultPaymentTypes, getClientToken, default as useBraintreeDropIn } from './useBraintreeDropIn.js';
+import 'braintree-web-drop-in';
+import '@vue/composition-api';

package/dist/index.js

@@ -0,0 +1,40 @@
+import {
+  setTipDonation
+} from "./chunk-KSEC5YWO.js";
+import {
+  getBasketID,
+  getCookieValue,
+  setBasketID
+} from "./chunk-F6QCMBHV.js";
+import {
+  executeOneTimeCheckout,
+  waitOnTransaction
+} from "./chunk-M4CJOCIQ.js";
+import {
+  checkSubscriptionStatus,
+  executeNewSubscriptionCheckout
+} from "./chunk-V2I7V4QJ.js";
+import {
+  defaultPaymentTypes,
+  getClientToken,
+  useBraintreeDropIn
+} from "./chunk-R27YZQKP.js";
+import {
+  ShopError,
+  parseShopError
+} from "./chunk-H35VQXDR.js";
+export {
+  ShopError,
+  checkSubscriptionStatus,
+  defaultPaymentTypes,
+  executeNewSubscriptionCheckout,
+  executeOneTimeCheckout,
+  getBasketID,
+  getClientToken,
+  getCookieValue,
+  parseShopError,
+  setBasketID,
+  setTipDonation,
+  useBraintreeDropIn,
+  waitOnTransaction
+};

package/dist/oneTimeCheckout.cjs

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/oneTimeCheckout.ts
+var oneTimeCheckout_exports = {};
+__export(oneTimeCheckout_exports, {
+  executeOneTimeCheckout: () => executeOneTimeCheckout,
+  waitOnTransaction: () => waitOnTransaction
+});
+module.exports = __toCommonJS(oneTimeCheckout_exports);
+var import_core = require("@apollo/client/core");
+async function executeOneTimeCheckout({ apollo }) {
+}
+async function waitOnTransaction({ apollo, transactionId }) {
+  const result = await apollo.query({
+    query: import_core.gql`
+			query checkoutStatus($transactionId: String!, $visitorId: string) {
+				checkoutStatus(transactionId: $transactionId, visitorId: $visitorId) {
+					errorCode
+					errorMessage
+					status
+					transactionId
+				}
+			}
+		`,
+    variables: {
+      transactionId
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeOneTimeCheckout,
+  waitOnTransaction
+});

package/dist/oneTimeCheckout.d.ts

@@ -0,0 +1,13 @@
+interface OneTimeCheckoutOptions {
+    apollo: any;
+    basketId: string;
+    visitorId: string | null | undefined;
+}
+declare function executeOneTimeCheckout({ apollo }: OneTimeCheckoutOptions): Promise<void>;
+interface WaitOnTransactionOptions {
+    apollo: any;
+    transactionId: string;
+}
+declare function waitOnTransaction({ apollo, transactionId }: WaitOnTransactionOptions): Promise<void>;
+
+export { OneTimeCheckoutOptions, WaitOnTransactionOptions, executeOneTimeCheckout, waitOnTransaction };

package/dist/oneTimeCheckout.js

@@ -0,0 +1,8 @@
+import {
+  executeOneTimeCheckout,
+  waitOnTransaction
+} from "./chunk-M4CJOCIQ.js";
+export {
+  executeOneTimeCheckout,
+  waitOnTransaction
+};

package/dist/shopError.cjs

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shopError.ts
+var shopError_exports = {};
+__export(shopError_exports, {
+  ShopError: () => ShopError,
+  parseShopError: () => parseShopError
+});
+module.exports = __toCommonJS(shopError_exports);
+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;
+  }
+};
+function parseShopError(error) {
+  const errorCode = error?.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.");
+  }
+  return new ShopError({
+    code: "shop.unknown",
+    original: error
+  }, "An unknown error occurred.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ShopError,
+  parseShopError
+});

package/dist/shopError.d.ts

@@ -0,0 +1,12 @@
+interface ShopErrorOptions {
+    code: string;
+    original?: object;
+}
+declare class ShopError extends Error {
+    code: string;
+    original?: object;
+    constructor({ code, original }: ShopErrorOptions, ...params: any[]);
+}
+declare function parseShopError(error: any): ShopError;
+
+export { ShopError, ShopErrorOptions, parseShopError };

package/dist/shopError.js

@@ -0,0 +1,8 @@
+import {
+  ShopError,
+  parseShopError
+} from "./chunk-H35VQXDR.js";
+export {
+  ShopError,
+  parseShopError
+};