@storepecker/storefront-core 1.0.0

package/dist/chunk-LC5ZAUKL.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+var chunkA6IO3HIN_cjs = require('./chunk-A6IO3HIN.cjs');
+var chunkK44JZ5NL_cjs = require('./chunk-K44JZ5NL.cjs');
+var chunkN3CTXRFT_cjs = require('./chunk-N3CTXRFT.cjs');
+var axios = require('axios');
+
+// src/checkout/payment.ts
+function openRazorpayCheckout(order, callbacks) {
+  if (!order) return;
+  chunkK44JZ5NL_cjs.pixelEvents.initiateCheckout(order, "razorpay");
+  const {
+    razorpay_order_id,
+    razorpay_public_token,
+    total_amount,
+    razorpay_order_currency,
+    store_color_scheme,
+    store_logo,
+    store_name,
+    customer_name,
+    customer_phone,
+    customer_email
+  } = order;
+  const cloudFront = chunkN3CTXRFT_cjs.getCloudFront();
+  const options = {
+    key: razorpay_public_token,
+    amount: Number(total_amount) * 100,
+    currency: razorpay_order_currency,
+    name: store_name,
+    image: cloudFront ? `${cloudFront}${store_logo}` : store_logo,
+    order_id: razorpay_order_id,
+    handler: async (response) => {
+      handleRazorpaySuccess(
+        {
+          razorpay_payment_id: response.razorpay_payment_id,
+          razorpay_subscription_id: response.razorpay_subscription_id,
+          razorpay_signature: response.razorpay_signature,
+          order_id: order.id,
+          razorpay_order_id,
+          payment_id: response.razorpay_payment_id
+        },
+        order,
+        callbacks
+      );
+    },
+    theme: {
+      color: store_color_scheme?.primary,
+      accent: store_color_scheme?.secondary
+    },
+    prefill: {
+      name: customer_name,
+      email: customer_email,
+      phone: customer_phone
+    },
+    modal: {
+      ondismiss: () => handleRazorpayFail(order, callbacks)
+    }
+  };
+  const paymentObject = new window.Razorpay(options);
+  paymentObject.on("payment.failed", () => {
+    handleRazorpayFail(order, callbacks);
+  });
+  paymentObject.open();
+}
+async function handleRazorpaySuccess(data, order, callbacks) {
+  try {
+    callbacks.onPaymentStart?.();
+    await chunkA6IO3HIN_cjs.razorpayOrderSuccess(data);
+    chunkK44JZ5NL_cjs.pixelEvents.purchase(order);
+    chunkK44JZ5NL_cjs.pixelEvents.checkoutCompleted(order);
+    callbacks.onCartReset();
+    callbacks.onSuccess(order);
+  } catch {
+    callbacks.onFailure(order);
+  } finally {
+    callbacks.onPaymentEnd?.();
+  }
+}
+async function handleRazorpayFail(order, callbacks) {
+  try {
+    await chunkA6IO3HIN_cjs.razorpayOrderFail({
+      order_id: order.id,
+      razorpay_order_id: order.razorpay_order_id
+    });
+  } catch {
+  }
+  callbacks.onFailure(order);
+}
+function handlePhonepePayment(order, callbacks) {
+  if (!order) return;
+  chunkK44JZ5NL_cjs.pixelEvents.initiateCheckout(order, "phonepe");
+  if (!order.phonepe_redirect_url) {
+    callbacks.onFailure(order);
+    return;
+  }
+  callbacks.onRedirect(order.phonepe_redirect_url);
+}
+function handleTabbyPayment(order, callbacks) {
+  if (!order) return;
+  chunkK44JZ5NL_cjs.pixelEvents.initiateCheckout(order, "tabby");
+  if (!order.tabby_redirect_url) {
+    callbacks.onFailure(order);
+    return;
+  }
+  callbacks.onRedirect(order.tabby_redirect_url);
+}
+async function handleCODPayment(order, callbacks, options) {
+  if (!order) return;
+  try {
+    callbacks.onPaymentStart?.();
+    chunkK44JZ5NL_cjs.pixelEvents.initiateCheckout(order, "cod");
+    if (options?.isPublic) {
+      await chunkA6IO3HIN_cjs.publicMakeCODOrder(order.order_number);
+    } else {
+      await chunkA6IO3HIN_cjs.makeCODOrder(order.id);
+    }
+    chunkK44JZ5NL_cjs.pixelEvents.purchase(order);
+    chunkK44JZ5NL_cjs.pixelEvents.checkoutCompleted(order);
+    callbacks.onCartReset();
+    callbacks.onSuccess(order);
+  } catch {
+    callbacks.onFailure(order);
+  } finally {
+    callbacks.onPaymentEnd?.();
+  }
+}
+function handleStripePayment(order, callbacks) {
+  if (!order) return;
+  chunkK44JZ5NL_cjs.pixelEvents.initiateCheckout(order, "stripe");
+  if (order.stripe_payment_link_url) {
+    callbacks.onRedirect(order.stripe_payment_link_url);
+    return;
+  }
+  if (order.stripe_client_secret) {
+    callbacks.onStripeModalOpen?.(order);
+    return;
+  }
+  callbacks.onFailure(order);
+}
+async function handleStripeSuccess(order, paymentIntentId, callbacks) {
+  try {
+    callbacks.onPaymentStart?.();
+    await chunkA6IO3HIN_cjs.stripeOrderSuccess({
+      order_id: order.id,
+      payment_intent_id: paymentIntentId
+    });
+    chunkK44JZ5NL_cjs.pixelEvents.purchase(order);
+    chunkK44JZ5NL_cjs.pixelEvents.checkoutCompleted(order);
+    callbacks.onCartReset();
+    callbacks.onSuccess(order);
+  } catch {
+    callbacks.onFailure(order);
+  } finally {
+    callbacks.onPaymentEnd?.();
+  }
+}
+function processPayment(order, paymentMethod, callbacks, options) {
+  if (paymentMethod === "cod") {
+    handleCODPayment(order, callbacks, options);
+    return;
+  }
+  if (order.tabby_redirect_url) {
+    handleTabbyPayment(order, callbacks);
+    return;
+  }
+  if (order.stripe_client_secret || order.stripe_payment_link_url) {
+    handleStripePayment(order, callbacks);
+    return;
+  }
+  if (order.razorpay_public_token) {
+    openRazorpayCheckout(order, callbacks);
+    return;
+  }
+  handlePhonepePayment(order, callbacks);
+}
+async function fetchAvailableCoupons() {
+  const response = await chunkA6IO3HIN_cjs.getCoupons();
+  return response.data;
+}
+async function fetchAppliedCoupon() {
+  try {
+    const response = await chunkA6IO3HIN_cjs.getAppliedCoupon();
+    return response.data || null;
+  } catch {
+    return null;
+  }
+}
+async function applyCheckoutCoupon(code, callbacks) {
+  try {
+    const response = await chunkA6IO3HIN_cjs.applyCoupon(code);
+    if (response.data?.coupon) {
+      await callbacks.onCartRefresh();
+      return response.data.coupon;
+    }
+    throw new Error("Failed to apply coupon");
+  } catch (error) {
+    if (error instanceof axios.AxiosError) {
+      throw new Error(error.response?.data?.detail || "Failed to apply coupon");
+    }
+    throw error;
+  }
+}
+async function removeCheckoutCoupon(couponCode, callbacks) {
+  await chunkA6IO3HIN_cjs.removeCoupon(couponCode);
+  await callbacks.onCartRefresh();
+}
+
+exports.applyCheckoutCoupon = applyCheckoutCoupon;
+exports.fetchAppliedCoupon = fetchAppliedCoupon;
+exports.fetchAvailableCoupons = fetchAvailableCoupons;
+exports.handleCODPayment = handleCODPayment;
+exports.handlePhonepePayment = handlePhonepePayment;
+exports.handleRazorpayFail = handleRazorpayFail;
+exports.handleRazorpaySuccess = handleRazorpaySuccess;
+exports.handleStripePayment = handleStripePayment;
+exports.handleStripeSuccess = handleStripeSuccess;
+exports.handleTabbyPayment = handleTabbyPayment;
+exports.openRazorpayCheckout = openRazorpayCheckout;
+exports.processPayment = processPayment;
+exports.removeCheckoutCoupon = removeCheckoutCoupon;

package/dist/chunk-N3CTXRFT.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+// src/utils/config.ts
+var _config = null;
+function initConfig(config) {
+  _config = config;
+}
+function getConfig() {
+  if (!_config) {
+    throw new Error(
+      "Snapstore config not initialized. Call initConfig() in your app's entry point."
+    );
+  }
+  return _config;
+}
+var getPublicApiEndpoint = () => getConfig().publicApiEndpoint;
+var getApiEndpoint = () => getConfig().apiEndpoint;
+var getStoreId = () => getConfig().storeId || "";
+var getSecretKey = () => getConfig().secretKey || "alohomora";
+var getCloudFront = () => getConfig().cloudFront;
+var getPhonePeApiEndpoint = () => getConfig().phonePeApiEndpoint;
+
+exports.getApiEndpoint = getApiEndpoint;
+exports.getCloudFront = getCloudFront;
+exports.getConfig = getConfig;
+exports.getPhonePeApiEndpoint = getPhonePeApiEndpoint;
+exports.getPublicApiEndpoint = getPublicApiEndpoint;
+exports.getSecretKey = getSecretKey;
+exports.getStoreId = getStoreId;
+exports.initConfig = initConfig;

package/dist/chunk-QCQCFYYR.js

@@ -0,0 +1,206 @@
+import { razorpayOrderSuccess, razorpayOrderFail, publicMakeCODOrder, makeCODOrder, stripeOrderSuccess, getCoupons, getAppliedCoupon, applyCoupon, removeCoupon } from './chunk-4MJMNIAB.js';
+import { pixelEvents } from './chunk-WFDKKOO7.js';
+import { getCloudFront } from './chunk-JQMLHRWL.js';
+import { AxiosError } from 'axios';
+
+// src/checkout/payment.ts
+function openRazorpayCheckout(order, callbacks) {
+  if (!order) return;
+  pixelEvents.initiateCheckout(order, "razorpay");
+  const {
+    razorpay_order_id,
+    razorpay_public_token,
+    total_amount,
+    razorpay_order_currency,
+    store_color_scheme,
+    store_logo,
+    store_name,
+    customer_name,
+    customer_phone,
+    customer_email
+  } = order;
+  const cloudFront = getCloudFront();
+  const options = {
+    key: razorpay_public_token,
+    amount: Number(total_amount) * 100,
+    currency: razorpay_order_currency,
+    name: store_name,
+    image: cloudFront ? `${cloudFront}${store_logo}` : store_logo,
+    order_id: razorpay_order_id,
+    handler: async (response) => {
+      handleRazorpaySuccess(
+        {
+          razorpay_payment_id: response.razorpay_payment_id,
+          razorpay_subscription_id: response.razorpay_subscription_id,
+          razorpay_signature: response.razorpay_signature,
+          order_id: order.id,
+          razorpay_order_id,
+          payment_id: response.razorpay_payment_id
+        },
+        order,
+        callbacks
+      );
+    },
+    theme: {
+      color: store_color_scheme?.primary,
+      accent: store_color_scheme?.secondary
+    },
+    prefill: {
+      name: customer_name,
+      email: customer_email,
+      phone: customer_phone
+    },
+    modal: {
+      ondismiss: () => handleRazorpayFail(order, callbacks)
+    }
+  };
+  const paymentObject = new window.Razorpay(options);
+  paymentObject.on("payment.failed", () => {
+    handleRazorpayFail(order, callbacks);
+  });
+  paymentObject.open();
+}
+async function handleRazorpaySuccess(data, order, callbacks) {
+  try {
+    callbacks.onPaymentStart?.();
+    await razorpayOrderSuccess(data);
+    pixelEvents.purchase(order);
+    pixelEvents.checkoutCompleted(order);
+    callbacks.onCartReset();
+    callbacks.onSuccess(order);
+  } catch {
+    callbacks.onFailure(order);
+  } finally {
+    callbacks.onPaymentEnd?.();
+  }
+}
+async function handleRazorpayFail(order, callbacks) {
+  try {
+    await razorpayOrderFail({
+      order_id: order.id,
+      razorpay_order_id: order.razorpay_order_id
+    });
+  } catch {
+  }
+  callbacks.onFailure(order);
+}
+function handlePhonepePayment(order, callbacks) {
+  if (!order) return;
+  pixelEvents.initiateCheckout(order, "phonepe");
+  if (!order.phonepe_redirect_url) {
+    callbacks.onFailure(order);
+    return;
+  }
+  callbacks.onRedirect(order.phonepe_redirect_url);
+}
+function handleTabbyPayment(order, callbacks) {
+  if (!order) return;
+  pixelEvents.initiateCheckout(order, "tabby");
+  if (!order.tabby_redirect_url) {
+    callbacks.onFailure(order);
+    return;
+  }
+  callbacks.onRedirect(order.tabby_redirect_url);
+}
+async function handleCODPayment(order, callbacks, options) {
+  if (!order) return;
+  try {
+    callbacks.onPaymentStart?.();
+    pixelEvents.initiateCheckout(order, "cod");
+    if (options?.isPublic) {
+      await publicMakeCODOrder(order.order_number);
+    } else {
+      await makeCODOrder(order.id);
+    }
+    pixelEvents.purchase(order);
+    pixelEvents.checkoutCompleted(order);
+    callbacks.onCartReset();
+    callbacks.onSuccess(order);
+  } catch {
+    callbacks.onFailure(order);
+  } finally {
+    callbacks.onPaymentEnd?.();
+  }
+}
+function handleStripePayment(order, callbacks) {
+  if (!order) return;
+  pixelEvents.initiateCheckout(order, "stripe");
+  if (order.stripe_payment_link_url) {
+    callbacks.onRedirect(order.stripe_payment_link_url);
+    return;
+  }
+  if (order.stripe_client_secret) {
+    callbacks.onStripeModalOpen?.(order);
+    return;
+  }
+  callbacks.onFailure(order);
+}
+async function handleStripeSuccess(order, paymentIntentId, callbacks) {
+  try {
+    callbacks.onPaymentStart?.();
+    await stripeOrderSuccess({
+      order_id: order.id,
+      payment_intent_id: paymentIntentId
+    });
+    pixelEvents.purchase(order);
+    pixelEvents.checkoutCompleted(order);
+    callbacks.onCartReset();
+    callbacks.onSuccess(order);
+  } catch {
+    callbacks.onFailure(order);
+  } finally {
+    callbacks.onPaymentEnd?.();
+  }
+}
+function processPayment(order, paymentMethod, callbacks, options) {
+  if (paymentMethod === "cod") {
+    handleCODPayment(order, callbacks, options);
+    return;
+  }
+  if (order.tabby_redirect_url) {
+    handleTabbyPayment(order, callbacks);
+    return;
+  }
+  if (order.stripe_client_secret || order.stripe_payment_link_url) {
+    handleStripePayment(order, callbacks);
+    return;
+  }
+  if (order.razorpay_public_token) {
+    openRazorpayCheckout(order, callbacks);
+    return;
+  }
+  handlePhonepePayment(order, callbacks);
+}
+async function fetchAvailableCoupons() {
+  const response = await getCoupons();
+  return response.data;
+}
+async function fetchAppliedCoupon() {
+  try {
+    const response = await getAppliedCoupon();
+    return response.data || null;
+  } catch {
+    return null;
+  }
+}
+async function applyCheckoutCoupon(code, callbacks) {
+  try {
+    const response = await applyCoupon(code);
+    if (response.data?.coupon) {
+      await callbacks.onCartRefresh();
+      return response.data.coupon;
+    }
+    throw new Error("Failed to apply coupon");
+  } catch (error) {
+    if (error instanceof AxiosError) {
+      throw new Error(error.response?.data?.detail || "Failed to apply coupon");
+    }
+    throw error;
+  }
+}
+async function removeCheckoutCoupon(couponCode, callbacks) {
+  await removeCoupon(couponCode);
+  await callbacks.onCartRefresh();
+}
+
+export { applyCheckoutCoupon, fetchAppliedCoupon, fetchAvailableCoupons, handleCODPayment, handlePhonepePayment, handleRazorpayFail, handleRazorpaySuccess, handleStripePayment, handleStripeSuccess, handleTabbyPayment, openRazorpayCheckout, processPayment, removeCheckoutCoupon };

package/dist/chunk-QM73PI5L.cjs

@@ -0,0 +1,218 @@
+'use strict';
+
+var chunkJHGXIIBZ_cjs = require('./chunk-JHGXIIBZ.cjs');
+var chunk4CVKE6CC_cjs = require('./chunk-4CVKE6CC.cjs');
+var chunkK5B62JZO_cjs = require('./chunk-K5B62JZO.cjs');
+var react = require('react');
+var formik = require('formik');
+var libphonenumberJs = require('libphonenumber-js');
+
+var defaultInitialValues = {
+  ...chunkK5B62JZO_cjs.addressFormInitialValues,
+  is_default: false,
+  country_obj: "IN"
+};
+function useAddressForm(options = {}) {
+  const {
+    address,
+    onSuccess,
+    onError,
+    locationCacheKey = chunkK5B62JZO_cjs.IP_API_CACHE_KEY,
+    defaultCountryId = 105
+  } = options;
+  const isEditing = !!address;
+  const [countries, setCountries] = react.useState([]);
+  const [states, setStates] = react.useState([]);
+  const [selectedCountry, setSelectedCountry] = react.useState(null);
+  const [addressMeta, setAddressMeta] = react.useState(null);
+  const [isSubmitting, setIsSubmitting] = react.useState(false);
+  const formik$1 = formik.useFormik({
+    initialValues: defaultInitialValues,
+    validationSchema: chunkK5B62JZO_cjs.addressValidationSchema,
+    onSubmit: async (values) => {
+      try {
+        setIsSubmitting(true);
+        const payload = chunkK5B62JZO_cjs.buildSubmitPayload(values, selectedCountry, states);
+        let response;
+        if (isEditing) {
+          response = await chunkJHGXIIBZ_cjs.updateAddress({
+            ...payload,
+            address_id: address.id
+          });
+        } else {
+          response = await chunkJHGXIIBZ_cjs.addAddress(payload);
+        }
+        if (response) {
+          formik$1.resetForm();
+          onSuccess?.(response.data, isEditing);
+        }
+      } catch (error) {
+        console.error(error);
+        onError?.(error);
+      } finally {
+        setIsSubmitting(false);
+      }
+    }
+  });
+  react.useEffect(() => {
+    const fetchCountries = async () => {
+      try {
+        const response = await chunkJHGXIIBZ_cjs.getCountries();
+        const sortedCountries = response?.data?.sort((a, b) => {
+          if (a.id === defaultCountryId) return -1;
+          if (b.id === defaultCountryId) return 1;
+          return 0;
+        });
+        setCountries(sortedCountries);
+      } catch (error) {
+        console.error(error);
+      }
+    };
+    fetchCountries();
+  }, [defaultCountryId]);
+  const supportedCountries = react.useMemo(
+    () => countries?.filter((c) => libphonenumberJs.isSupportedCountry(c.tld_code)) ?? [],
+    [countries]
+  );
+  const countryCodeOptions = react.useMemo(() => {
+    return supportedCountries?.map((c) => {
+      const callingCode = libphonenumberJs.getCountryCallingCode(c?.tld_code);
+      return {
+        value: c.tld_code,
+        label: `${c.name} (+${callingCode})`,
+        country: c
+      };
+    }) ?? [];
+  }, [supportedCountries]);
+  react.useEffect(() => {
+    if (!selectedCountry) return;
+    const fetchStates = async () => {
+      try {
+        const response = await chunkJHGXIIBZ_cjs.getSubdivisions(selectedCountry.id);
+        setStates(response.data.results);
+      } catch (error) {
+        console.error(error);
+      }
+    };
+    const fetchAddressMeta = async () => {
+      try {
+        const response = await chunk4CVKE6CC_cjs.getAddressMeta(
+          selectedCountry.tld_code
+        );
+        setAddressMeta(response);
+        if (!response?.hasPostal) {
+          formik$1.setFieldValue("pincode", "N/A");
+        } else {
+          if (formik$1.values.pincode === "N/A") {
+            formik$1.setFieldValue("pincode", "");
+          }
+        }
+      } catch (error) {
+        console.error(error);
+      }
+    };
+    fetchStates();
+    fetchAddressMeta();
+  }, [selectedCountry]);
+  react.useEffect(() => {
+    if (countries.length > 0 && formik$1.values.customer_country_code && !selectedCountry) {
+      const found = countries.find(
+        (c) => c.tld_code === formik$1.values.customer_country_code
+      );
+      if (found) {
+        setSelectedCountry(found);
+      }
+    }
+  }, [countries, formik$1.values.customer_country_code]);
+  react.useEffect(() => {
+    if (supportedCountries.length === 0) return;
+    if (address) {
+      const addressValues = { ...address };
+      if (addressValues.country_obj) {
+        const foundCountry = supportedCountries.find(
+          (c) => c.id === Number(addressValues.country_obj)
+        );
+        if (foundCountry) {
+          setSelectedCountry(foundCountry);
+        }
+      }
+      if (addressValues?.customer_country_code) {
+        const foundCountry = supportedCountries.find(
+          (c) => libphonenumberJs.getCountryCallingCode(c.tld_code) === addressValues.customer_country_code.slice(1)
+        );
+        if (foundCountry) {
+          addressValues.customer_country_code = foundCountry.tld_code;
+        }
+      }
+      formik$1.setValues(addressValues);
+    } else {
+      const locationData = chunk4CVKE6CC_cjs.getCache(locationCacheKey);
+      if (locationData) {
+        const { country_code = "IN" } = locationData;
+        const foundCountry = supportedCountries.find(
+          (c) => c.tld_code === country_code
+        );
+        if (foundCountry) {
+          setSelectedCountry(foundCountry);
+        }
+        formik$1.setValues({
+          ...defaultInitialValues,
+          customer_country_code: country_code,
+          country_obj: country_code
+        });
+      } else {
+        formik$1.setValues(defaultInitialValues);
+      }
+    }
+  }, [address, supportedCountries]);
+  const handlePhoneCountryChange = react.useCallback(
+    (value) => {
+      formik$1.setFieldValue("customer_country_code", value);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const handleCountryCodeChange = react.useCallback(
+    (value) => {
+      const country = supportedCountries.find(
+        (c) => c.tld_code === value
+      );
+      if (country) {
+        setSelectedCountry(country);
+      }
+    },
+    [supportedCountries]
+  );
+  const handleStateChange = react.useCallback(
+    (e) => {
+      formik$1.setFieldValue("state_obj", e.target.value);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const handlePhoneChange = react.useCallback(
+    (e) => {
+      const cleaned = e.target.value.trim().replace(/^0+/, "");
+      formik$1.setFieldValue("customer_phone", cleaned);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  return {
+    formik: formik$1,
+    countries,
+    supportedCountries,
+    states,
+    selectedCountry,
+    countryCodeOptions,
+    addressMeta,
+    handlePhoneCountryChange,
+    handleCountryCodeChange,
+    handleStateChange,
+    handlePhoneChange,
+    isSubmitting,
+    isEditing
+  };
+}
+
+exports.useAddressForm = useAddressForm;