@storepecker/storefront-core 1.0.0

package/dist/chunk-RCXQJ6XC.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+var chunkCFF632IQ_cjs = require('./chunk-CFF632IQ.cjs');
+var chunkUXLUE3HW_cjs = require('./chunk-UXLUE3HW.cjs');
+var chunkGQTO5ZE2_cjs = require('./chunk-GQTO5ZE2.cjs');
+
+// src/api/cart.ts
+async function getCart(url, addressId) {
+  const localCart = chunkCFF632IQ_cjs.cart_default.get();
+  return chunkGQTO5ZE2_cjs.auth_default.getUserDetails() ? (await chunkUXLUE3HW_cjs.http_service_default.get(url, { params: { address_id: addressId } })).data : localCart || {
+    product_variants: [],
+    total_amount: 0,
+    total_quantity: 0,
+    products_quantity: {},
+    cart_count: 0,
+    missing_items: [],
+    customization_inputs: [],
+    total_coupon_discount: 0,
+    variant_discounts: {},
+    total_shipping: 0,
+    total_tax_amount: 0
+  };
+}
+async function addToCart(product, customizationInputs) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/cart/", {
+    action: "add",
+    cart_items: product,
+    customization_inputs: customizationInputs
+  });
+}
+async function removeFromCart(product) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/cart/", {
+    action: "remove",
+    cart_items: product
+  });
+}
+async function updateCart(product) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/cart/", {
+    action: "update",
+    cart_items: product
+  });
+}
+
+// src/api/product.ts
+async function getProductList(url, filter) {
+  const response = await chunkUXLUE3HW_cjs.http_service_default.get(url, {
+    params: filter
+  });
+  return response.data;
+}
+async function getProducts(filter) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/inventory/products/", {
+    params: { ...filter }
+  });
+}
+async function getProductDetail(url, slug) {
+  const response = await chunkUXLUE3HW_cjs.http_service_default.get(url, {
+    params: { variant_slug: slug }
+  });
+  return response.data;
+}
+async function getProductCategories(url) {
+  return await chunkUXLUE3HW_cjs.http_service_default.get(url);
+}
+async function getDigitalProductDownloadLink(variantId) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/inventory/digital_product/download/", {
+    params: { variant_id: variantId }
+  });
+}
+async function updateDigitalProductDownloadLinkCount(variantId, downloadLink) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/inventory/digital_product/download/", {
+    variant_id: variantId,
+    download_link: downloadLink
+  });
+}
+async function getCategories(responseType = "flat") {
+  return await chunkUXLUE3HW_cjs.http_service_default.get("/inventory/categories/", {
+    params: { response_structure: responseType }
+  });
+}
+async function getProductDetailBySlug(url, slug) {
+  const response = await chunkUXLUE3HW_cjs.http_service_default.get(url, {
+    params: { variant_slug: slug }
+  });
+  const product = response.data;
+  const variantAttributes = product.variants.map((variant) => ({
+    ...variant.attributes,
+    slug: variant.slug
+  }));
+  variantAttributes.push({
+    ...product.attributes,
+    slug: product.slug
+  });
+  product.variantAttributes = variantAttributes;
+  return product;
+}
+async function notifyProductStock(userDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/utils/customer/notify-me/", userDetails);
+}
+
+// src/api/wishlist.ts
+async function getWishlist(url) {
+  const response = await chunkUXLUE3HW_cjs.http_service_default.get(url);
+  return response.data;
+}
+async function addWishlist(productDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/wishlist/", productDetails);
+}
+async function removeFromWishlist(product_variants) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/wishlist/", {
+    action: "remove",
+    product_variants
+  });
+}
+
+exports.addToCart = addToCart;
+exports.addWishlist = addWishlist;
+exports.getCart = getCart;
+exports.getCategories = getCategories;
+exports.getDigitalProductDownloadLink = getDigitalProductDownloadLink;
+exports.getProductCategories = getProductCategories;
+exports.getProductDetail = getProductDetail;
+exports.getProductDetailBySlug = getProductDetailBySlug;
+exports.getProductList = getProductList;
+exports.getProducts = getProducts;
+exports.getWishlist = getWishlist;
+exports.notifyProductStock = notifyProductStock;
+exports.removeFromCart = removeFromCart;
+exports.removeFromWishlist = removeFromWishlist;
+exports.updateCart = updateCart;
+exports.updateDigitalProductDownloadLinkCount = updateDigitalProductDownloadLinkCount;

package/dist/chunk-UM24VDYB.js

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

package/dist/chunk-UXLUE3HW.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+var chunkGQTO5ZE2_cjs = require('./chunk-GQTO5ZE2.cjs');
+var chunkN3CTXRFT_cjs = require('./chunk-N3CTXRFT.cjs');
+var axios = require('axios');
+var typescriptCookie = require('typescript-cookie');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var _instance = null;
+function createInstance() {
+  const baseURL = chunkN3CTXRFT_cjs.getPublicApiEndpoint();
+  if (!baseURL) {
+    throw new Error("Missing API endpoint. Call initConfig() first.");
+  }
+  axios__default.default.defaults.withCredentials = true;
+  const instance = axios__default.default.create({
+    baseURL,
+    withCredentials: true
+  });
+  const onRequestSuccess = (config) => {
+    const csrftoken = typescriptCookie.getCookie("csrftoken");
+    const token = chunkGQTO5ZE2_cjs.auth_default.getAccessToken();
+    config.headers["X-CSRFToken"] = csrftoken;
+    if (token) config.headers["Authorization"] = `Bearer ${token}`;
+    const storeId = chunkN3CTXRFT_cjs.getStoreId();
+    if (storeId) config.headers[""] = `Store ${storeId}`;
+    return config;
+  };
+  const onRequestFail = (error) => {
+    return Promise.reject(error);
+  };
+  instance.interceptors.request.use(onRequestSuccess, onRequestFail);
+  const onResponseSuccess = (response) => {
+    return response;
+  };
+  const onResponseFail = (error) => {
+    if (error && !error.response) ; else {
+      const status = error.response?.status;
+      if (status === 401) {
+        error.response?.data?.detail;
+      }
+    }
+    return Promise.reject(error);
+  };
+  instance.interceptors.response.use(onResponseSuccess, onResponseFail);
+  return instance;
+}
+function getHttpService() {
+  if (!_instance) {
+    _instance = createInstance();
+  }
+  return _instance;
+}
+function resetHttpService() {
+  _instance = null;
+}
+var httpService = new Proxy({}, {
+  get(_target, prop) {
+    return getHttpService()[prop];
+  }
+});
+var http_service_default = httpService;
+
+exports.getHttpService = getHttpService;
+exports.http_service_default = http_service_default;
+exports.resetHttpService = resetHttpService;

package/dist/chunk-WFDKKOO7.js

@@ -0,0 +1,210 @@
+// src/utils/pixelEvents.ts
+var pixelEvents = {
+  /**
+   * Track when a user views a product
+   */
+  productView: (product) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "product_viewed", {
+        content_slug: product.slug,
+        content_name: product.name,
+        content_type: "product",
+        currency: window.currency_code || "INR",
+        price: Number(product.selling_price),
+        attributes: product.attributes,
+        value: Number(product.selling_price)
+      });
+    } catch (error) {
+      console.error("Facebook Pixel ViewContent Event Error:", error);
+    }
+  },
+  /**
+   * Track when a product is added to cart
+   */
+  addToCart: (product, quantity = 1) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "product_added_to_cart", {
+        content_slug: product.slug,
+        content_name: product.name,
+        content_type: "product",
+        price: Number(product.selling_price) * quantity,
+        num_items: quantity,
+        attributes: product.attributes
+      });
+    } catch (error) {
+      console.error("Facebook Pixel AddToCart Event Error:", error);
+    }
+  },
+  removeFromCart: (product) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "product_removed_from_cart", {
+        content_slug: product.slug,
+        content_name: product.name,
+        content_type: "product",
+        price: Number(product.selling_price),
+        attributes: product.attributes
+      });
+    } catch (error) {
+      console.error("Facebook Pixel RemoveFromCart Event Error:", error);
+    }
+  },
+  /**
+   * Track when a product is added to wishlist
+   */
+  addToWishlist: (product) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "product_added_to_wishlist", {
+        content_slug: product.slug,
+        content_name: product.name,
+        content_type: "product",
+        price: Number(product.selling_price),
+        attributes: product.attributes
+      });
+    } catch (error) {
+      console.error("Facebook Pixel AddToWishlist Event Error:", error);
+    }
+  },
+  /**
+   * Track when user initiates checkout
+   */
+  initiateCheckout: (orderSummary, paymentMethod) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "checkout_started", {
+        order_number: orderSummary.order_number,
+        content_type: "product",
+        currency: window.currency_code || "INR",
+        price: orderSummary.total_amount,
+        value: orderSummary.total_amount,
+        num_items: orderSummary.purchased_products.length,
+        contents: orderSummary.purchased_products.map((item) => ({
+          name: item.product_variant_name,
+          quantity: item.quantity,
+          item_price: Number(item.total_price),
+          sku: item.product_variant_sku
+        })),
+        payment_method: paymentMethod
+      });
+    } catch (error) {
+      console.error("Facebook Pixel InitiateCheckout Event Error:", error);
+    }
+  },
+  /**
+   * Track successful purchases
+   */
+  purchase: (orderSummary) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "purchase", {
+        content_ids: [orderSummary.order_number],
+        order_number: orderSummary.order_number,
+        content_type: "product",
+        currency: window.currency_code || "INR",
+        price: orderSummary.total_amount,
+        value: orderSummary.total_amount,
+        num_items: orderSummary.purchased_products.length,
+        contents: orderSummary.purchased_products.map((item) => ({
+          name: item.product_variant_name,
+          quantity: item.quantity,
+          item_price: Number(item.total_price),
+          sku: item.product_variant_sku
+        }))
+      });
+    } catch (error) {
+      console.error("Facebook Pixel Purchase Event Error:", error);
+    }
+  },
+  /**
+   * Track search events
+   */
+  search: (searchTerm, resultCount) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "search_submitted", {
+        search_string: searchTerm,
+        content_type: "product",
+        success: resultCount > 0,
+        num_results: resultCount
+      });
+    } catch (error) {
+      console.error("Facebook Pixel Search Event Error:", error);
+    }
+  },
+  /**
+   * Track when a user views their cart
+   */
+  cartView: (cart) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "cart_viewed", {
+        content_type: "cart",
+        value: cart.total_amount,
+        number_of_products: cart.total_quantity
+      });
+    } catch (error) {
+      console.error("Facebook Pixel Cart View Event Error:", error);
+    }
+  },
+  /**
+   * Track when a user completes a checkout
+   */
+  checkoutCompleted: (orderSummary) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "checkout_completed", {
+        content_ids: [orderSummary.order_number],
+        order_number: orderSummary.order_number,
+        content_type: "product",
+        currency: "INR",
+        value: orderSummary.total_amount,
+        num_items: orderSummary.purchased_products.length,
+        contents: orderSummary.purchased_products.map((item) => ({
+          name: item.product_variant_name,
+          quantity: item.quantity,
+          item_price: Number(item.total_price),
+          sku: item.product_variant_sku
+        }))
+      });
+    } catch (error) {
+      console.error("Facebook Pixel Checkout Completed Event Error:", error);
+    }
+  },
+  addressInfoSubmitted: () => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "checkout_address_info_submitted", {
+        content_type: "address"
+      });
+    } catch (error) {
+      console.error(
+        "Facebook Pixel Address Info Submitted Event Error:",
+        error
+      );
+    }
+  },
+  checkoutStarted: (cart) => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "checkout_started", {
+        value: cart.total_amount,
+        number_of_products: cart.total_quantity
+      });
+    } catch (error) {
+      console.error("Facebook Pixel Checkout Started Event Error:", error);
+    }
+  },
+  pageViewed: () => {
+    if (!window.fbq) return;
+    try {
+      window.fbq("track", "page_viewed");
+    } catch (error) {
+      console.error("Facebook Pixel Page Viewed Event Error:", error);
+    }
+  }
+};
+
+export { pixelEvents };