@storepecker/storefront-core 1.0.0

package/dist/chunk-A6IO3HIN.cjs

@@ -0,0 +1,151 @@
+'use strict';
+
+var chunkUXLUE3HW_cjs = require('./chunk-UXLUE3HW.cjs');
+
+// src/api/coupon.ts
+async function getCoupons() {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/coupon/available/");
+}
+async function applyCoupon(couponCode) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/coupon/use/", { coupon_code: couponCode });
+}
+async function getAppliedCoupon() {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/coupon/use/");
+}
+async function removeCoupon(couponCode) {
+  return chunkUXLUE3HW_cjs.http_service_default.delete("/coupon/use/");
+}
+
+// src/api/orders.ts
+async function getOrders(url) {
+  const response = await chunkUXLUE3HW_cjs.http_service_default.get(url);
+  return response.data;
+}
+async function getOrderDetails(orderId) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/customer/order/", {
+    params: { order_id: orderId }
+  });
+}
+async function getOrderDetailsByNumber(orderNumber) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/customer/order/", {
+    params: { order_number: orderNumber }
+  });
+}
+async function getPublicOrderDetailsByNumber(orderNumber) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/customer/public_order/", {
+    params: { order_number: orderNumber }
+  });
+}
+async function placeOrder(address_id, redirect, isCod, stripeRedirect, tabbyRedirect) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/order/", {
+    address_id,
+    phonepe_redirect_url: redirect,
+    is_cod: isCod,
+    stripe_redirect_url: stripeRedirect,
+    tabby_redirect_url: tabbyRedirect
+  });
+}
+async function publicPlaceOrder(address, redirect, orderDetails, stripeRedirect, tabbyRedirect) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/public_order/", {
+    address,
+    phonepe_redirect_url: redirect,
+    stripe_redirect_url: stripeRedirect,
+    tabby_redirect_url: tabbyRedirect,
+    ...orderDetails
+  });
+}
+async function updateOrder(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.patch("/customer/order/", orderDetails);
+}
+async function razorpayPublicOrderSuccess(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/public-razorpay-order-success/", orderDetails);
+}
+async function razorpayOrderSuccess(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/razorpay-order-success/", orderDetails);
+}
+async function razorpayOrderFail(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/razorpay-order-fail/", orderDetails);
+}
+async function phonepePublicOrderSuccess(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/public-phonepe-order-success/", orderDetails);
+}
+async function phonepeOrderSuccess(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/phonepe-order-success/", orderDetails);
+}
+async function checkPhonepePaymentStatus(transactionId) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/payment/phonepe-order-success/", {
+    params: { phonepe_transaction_id: transactionId }
+  });
+}
+async function getStripePaymentStatus(stripeCheckoutSessionId, order_number, payment_link_id) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/payment/stripe-payment-status/", {
+    params: {
+      checkout_session_id: stripeCheckoutSessionId,
+      order_number,
+      payment_link_id
+    }
+  });
+}
+async function getStripePaymentStatusPublic(stripeCheckoutSessionId, order_number, payment_link_id) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/payment/public-stripe-payment-status/", {
+    params: {
+      checkout_session_id: stripeCheckoutSessionId,
+      order_number,
+      payment_link_id
+    }
+  });
+}
+async function stripePublicOrderSuccess(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/public-stripe-order-success/", orderDetails);
+}
+async function stripeOrderSuccess(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/stripe-order-success/", orderDetails);
+}
+async function stripeOrderFail(orderDetails) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/payment/stripe-order-fail/", orderDetails);
+}
+async function makeCODOrder(orderId) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/order_cod/", { order_id: orderId });
+}
+async function publicMakeCODOrder(orderNumber) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/public_order_cod/", { order_number: orderNumber });
+}
+async function updateOrderCustomization(customizationInput) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/customer/product_personalize/", customizationInput);
+}
+async function uploadCustomizationImage(uploadForm) {
+  return chunkUXLUE3HW_cjs.http_service_default.post("/utils/upload_image", uploadForm);
+}
+async function verifyTabbyPayment(orderNumber) {
+  return chunkUXLUE3HW_cjs.http_service_default.get("/payment/tabby-payment-status/", {
+    params: { order_number: orderNumber }
+  });
+}
+
+exports.applyCoupon = applyCoupon;
+exports.checkPhonepePaymentStatus = checkPhonepePaymentStatus;
+exports.getAppliedCoupon = getAppliedCoupon;
+exports.getCoupons = getCoupons;
+exports.getOrderDetails = getOrderDetails;
+exports.getOrderDetailsByNumber = getOrderDetailsByNumber;
+exports.getOrders = getOrders;
+exports.getPublicOrderDetailsByNumber = getPublicOrderDetailsByNumber;
+exports.getStripePaymentStatus = getStripePaymentStatus;
+exports.getStripePaymentStatusPublic = getStripePaymentStatusPublic;
+exports.makeCODOrder = makeCODOrder;
+exports.phonepeOrderSuccess = phonepeOrderSuccess;
+exports.phonepePublicOrderSuccess = phonepePublicOrderSuccess;
+exports.placeOrder = placeOrder;
+exports.publicMakeCODOrder = publicMakeCODOrder;
+exports.publicPlaceOrder = publicPlaceOrder;
+exports.razorpayOrderFail = razorpayOrderFail;
+exports.razorpayOrderSuccess = razorpayOrderSuccess;
+exports.razorpayPublicOrderSuccess = razorpayPublicOrderSuccess;
+exports.removeCoupon = removeCoupon;
+exports.stripeOrderFail = stripeOrderFail;
+exports.stripeOrderSuccess = stripeOrderSuccess;
+exports.stripePublicOrderSuccess = stripePublicOrderSuccess;
+exports.updateOrder = updateOrder;
+exports.updateOrderCustomization = updateOrderCustomization;
+exports.uploadCustomizationImage = uploadCustomizationImage;
+exports.verifyTabbyPayment = verifyTabbyPayment;

package/dist/chunk-CFF632IQ.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+var chunkGQTO5ZE2_cjs = require('./chunk-GQTO5ZE2.cjs');
+
+// src/utils/cart.ts
+var LocalCart = {
+  get() {
+    const storeData = localStorage.getItem(chunkGQTO5ZE2_cjs.USER_CART);
+    return storeData ? JSON.parse(storeData) : null;
+  },
+  set(cart) {
+    localStorage.setItem(chunkGQTO5ZE2_cjs.USER_CART, JSON.stringify(cart));
+  },
+  add(product) {
+    const cart = this.get();
+    if (!cart) {
+      this.set({
+        product_variants: [product],
+        products_quantity: { [product.id]: 1 },
+        total_quantity: 1,
+        cart_count: 1,
+        total_amount: product.selling_price,
+        variant_discounts: {}
+      });
+      return;
+    }
+    const newCart = cart.product_variants || [];
+    const existingProduct = newCart.find((prod) => prod.id === product.id);
+    if (existingProduct) {
+      cart.products_quantity = {
+        ...cart.products_quantity,
+        [product.id]: (Number(cart.products_quantity[product.id]) || 0) + 1
+      };
+      cart.total_quantity = Number(cart.total_quantity) + 1;
+      cart.cart_count = Number(cart.cart_count) + 1;
+      cart.total_amount = Number(cart.total_amount) + Number(product.selling_price);
+      this.set(cart);
+      return;
+    }
+    newCart.push(product);
+    cart.products_quantity = {
+      ...cart.products_quantity,
+      [product.id]: (cart.products_quantity[product.id] || 0) + 1
+    };
+    cart.product_variants = newCart;
+    cart.total_quantity = Number(cart.total_quantity) + 1;
+    cart.cart_count = Number(cart.cart_count) + 1;
+    cart.total_amount = Number(cart.total_amount) + Number(product.selling_price);
+    this.set(cart);
+  },
+  remove(product) {
+    const cart = this.get();
+    if (!cart) return;
+    const newCart = cart.product_variants?.filter(
+      (prod) => prod.id !== product.id
+    );
+    const quantity = cart.products_quantity[product.id] || 0;
+    cart.cart_count = (cart.cart_count || 0) - quantity;
+    cart.products_quantity = {
+      ...cart.products_quantity
+    };
+    if (cart.products_quantity[product.id]) {
+      delete cart.products_quantity[product.id];
+    }
+    cart.product_variants = newCart;
+    const currentTotalAmount = Number(cart.total_amount) || 0;
+    const itemPrice = Number(product.selling_price) || 0;
+    const itemTotalPrice = itemPrice * quantity;
+    cart.total_quantity = Math.max(
+      0,
+      (Number(cart.total_quantity) || 0) - quantity
+    );
+    cart.total_amount = Math.max(0, currentTotalAmount - itemTotalPrice);
+    this.set(cart);
+  },
+  updateQuantity(product, quantity) {
+    const cart = this.get();
+    if (!cart) return;
+    cart.products_quantity = {
+      ...cart.products_quantity,
+      [product.id]: quantity
+    };
+    cart.total_quantity = Object.values(cart.products_quantity).reduce(
+      (acc, curr) => acc + curr,
+      0
+    );
+    cart.total_amount = cart.product_variants.reduce(
+      (acc, curr) => acc + Number(curr.selling_price) * Number(cart.products_quantity[curr.id]),
+      0
+    );
+    Number(cart.total_amount) + Number(product.selling_price) * quantity;
+    this.set(cart);
+  },
+  clear() {
+    localStorage.removeItem(chunkGQTO5ZE2_cjs.USER_CART);
+  }
+};
+var cart_default = LocalCart;
+
+exports.cart_default = cart_default;

package/dist/chunk-CSISWBZZ.js

@@ -0,0 +1,121 @@
+import { ADDRESS_FORM_SESSION_KEY } from './chunk-FLBJKM6G.js';
+import { parsePhoneNumberFromString, getCountryCallingCode } from 'libphonenumber-js';
+import * as Yup from 'yup';
+
+var IP_API_CACHE_KEY = "ip_geolocation_data";
+var addressFormInitialValues = {
+  customer_phone: "",
+  customer_country_code: "IN",
+  customer_name: "",
+  pincode: "",
+  state_obj: "",
+  address: "",
+  street_name: "",
+  area: "",
+  city: "",
+  customer_email: ""
+};
+function isValidPhoneNumber(input, countryCode) {
+  if (!input) return false;
+  const phone = parsePhoneNumberFromString(input, countryCode);
+  return phone?.isValid() ?? false;
+}
+var addressValidationSchema = Yup.object({
+  customer_phone: Yup.string().required("Phone number required").test("is-valid", "Please enter a valid number", function(value) {
+    const { customer_country_code } = this.parent;
+    if (!value) return false;
+    return isValidPhoneNumber(value, customer_country_code);
+  }),
+  customer_name: Yup.string().required("Name is required"),
+  pincode: Yup.string().when("customer_country_code", {
+    is: "AE",
+    then: (schema) => schema.optional(),
+    otherwise: (schema) => schema.required("Pincode is required")
+  }),
+  state_obj: Yup.string().required("State is required"),
+  address: Yup.string().required("Address is required"),
+  street_name: Yup.string().optional(),
+  area: Yup.string().optional(),
+  city: Yup.string().required("City/District is required"),
+  customer_email: Yup.string().email("Please enter a valid email").required("Email is required")
+});
+function encodeAddress(id, city) {
+  return `${btoa(id.toString())}-${btoa(city)}`;
+}
+function decodeAddress(encoded) {
+  const [encodedId, encodedCity] = encoded.split("-");
+  return {
+    id: Number(atob(encodedId)),
+    city: atob(encodedCity)
+  };
+}
+function saveAddressFormToSession(values) {
+  try {
+    sessionStorage.setItem(ADDRESS_FORM_SESSION_KEY, JSON.stringify(values));
+  } catch {
+  }
+}
+function loadAddressFormFromSession() {
+  try {
+    const stored = sessionStorage.getItem(ADDRESS_FORM_SESSION_KEY);
+    return stored ? JSON.parse(stored) : null;
+  } catch {
+    return null;
+  }
+}
+function clearAddressFormSession() {
+  try {
+    sessionStorage.removeItem(ADDRESS_FORM_SESSION_KEY);
+  } catch {
+  }
+}
+function buildAddressPayload(formValues, selectedCountry, states) {
+  const selectedState = states.find((s) => s.name === formValues.state_obj);
+  return {
+    customer_name: formValues.customer_name,
+    customer_phone: formValues.customer_phone,
+    customer_country_code: formValues.customer_country_code,
+    customer_email: formValues.customer_email,
+    address: formValues.address,
+    street_name: formValues.street_name,
+    area: formValues.area,
+    city: formValues.city,
+    state: selectedState?.state_code || formValues.state_obj,
+    state_obj: formValues.state_obj,
+    country: selectedCountry.short_code,
+    pincode: formValues.pincode
+  };
+}
+function parseEditAddress(fullAddress) {
+  if (!fullAddress) return { address: "", street_name: "", area: "" };
+  const parts = fullAddress.split(",").map((s) => s.trim());
+  return {
+    address: parts[0] || "",
+    street_name: parts[1] || "",
+    area: parts[2] || ""
+  };
+}
+function buildSubmitPayload(values, country, states) {
+  const formValues = { ...values };
+  delete formValues.customer;
+  const stateName = states.find(
+    (s) => s.id === Number(values.state_obj)
+  )?.name;
+  let customerCountryCode = "";
+  if (values.customer_country_code) {
+    try {
+      customerCountryCode = `+${getCountryCallingCode(values.customer_country_code)}`;
+    } catch {
+      customerCountryCode = values.customer_country_code;
+    }
+  }
+  return {
+    ...formValues,
+    country: country?.name || "india",
+    country_obj: country?.id || 105,
+    customer_country_code: customerCountryCode,
+    state: stateName || values.state_obj
+  };
+}
+
+export { IP_API_CACHE_KEY, addressFormInitialValues, addressValidationSchema, buildAddressPayload, buildSubmitPayload, clearAddressFormSession, decodeAddress, encodeAddress, isValidPhoneNumber, loadAddressFormFromSession, parseEditAddress, saveAddressFormToSession };

package/dist/chunk-E7WPE3PV.js

@@ -0,0 +1,98 @@
+import { USER_CART } from './chunk-FLBJKM6G.js';
+
+// src/utils/cart.ts
+var LocalCart = {
+  get() {
+    const storeData = localStorage.getItem(USER_CART);
+    return storeData ? JSON.parse(storeData) : null;
+  },
+  set(cart) {
+    localStorage.setItem(USER_CART, JSON.stringify(cart));
+  },
+  add(product) {
+    const cart = this.get();
+    if (!cart) {
+      this.set({
+        product_variants: [product],
+        products_quantity: { [product.id]: 1 },
+        total_quantity: 1,
+        cart_count: 1,
+        total_amount: product.selling_price,
+        variant_discounts: {}
+      });
+      return;
+    }
+    const newCart = cart.product_variants || [];
+    const existingProduct = newCart.find((prod) => prod.id === product.id);
+    if (existingProduct) {
+      cart.products_quantity = {
+        ...cart.products_quantity,
+        [product.id]: (Number(cart.products_quantity[product.id]) || 0) + 1
+      };
+      cart.total_quantity = Number(cart.total_quantity) + 1;
+      cart.cart_count = Number(cart.cart_count) + 1;
+      cart.total_amount = Number(cart.total_amount) + Number(product.selling_price);
+      this.set(cart);
+      return;
+    }
+    newCart.push(product);
+    cart.products_quantity = {
+      ...cart.products_quantity,
+      [product.id]: (cart.products_quantity[product.id] || 0) + 1
+    };
+    cart.product_variants = newCart;
+    cart.total_quantity = Number(cart.total_quantity) + 1;
+    cart.cart_count = Number(cart.cart_count) + 1;
+    cart.total_amount = Number(cart.total_amount) + Number(product.selling_price);
+    this.set(cart);
+  },
+  remove(product) {
+    const cart = this.get();
+    if (!cart) return;
+    const newCart = cart.product_variants?.filter(
+      (prod) => prod.id !== product.id
+    );
+    const quantity = cart.products_quantity[product.id] || 0;
+    cart.cart_count = (cart.cart_count || 0) - quantity;
+    cart.products_quantity = {
+      ...cart.products_quantity
+    };
+    if (cart.products_quantity[product.id]) {
+      delete cart.products_quantity[product.id];
+    }
+    cart.product_variants = newCart;
+    const currentTotalAmount = Number(cart.total_amount) || 0;
+    const itemPrice = Number(product.selling_price) || 0;
+    const itemTotalPrice = itemPrice * quantity;
+    cart.total_quantity = Math.max(
+      0,
+      (Number(cart.total_quantity) || 0) - quantity
+    );
+    cart.total_amount = Math.max(0, currentTotalAmount - itemTotalPrice);
+    this.set(cart);
+  },
+  updateQuantity(product, quantity) {
+    const cart = this.get();
+    if (!cart) return;
+    cart.products_quantity = {
+      ...cart.products_quantity,
+      [product.id]: quantity
+    };
+    cart.total_quantity = Object.values(cart.products_quantity).reduce(
+      (acc, curr) => acc + curr,
+      0
+    );
+    cart.total_amount = cart.product_variants.reduce(
+      (acc, curr) => acc + Number(curr.selling_price) * Number(cart.products_quantity[curr.id]),
+      0
+    );
+    Number(cart.total_amount) + Number(product.selling_price) * quantity;
+    this.set(cart);
+  },
+  clear() {
+    localStorage.removeItem(USER_CART);
+  }
+};
+var cart_default = LocalCart;
+
+export { cart_default };

package/dist/chunk-FLBJKM6G.js

@@ -0,0 +1,83 @@
+import { removeCookie, getCookie, setCookie } from 'typescript-cookie';
+
+// src/utils/constants.ts
+var SLICE_STATUS = /* @__PURE__ */ ((SLICE_STATUS2) => {
+  SLICE_STATUS2["IDLE"] = "idle";
+  SLICE_STATUS2["LOADING"] = "loading";
+  SLICE_STATUS2["SUCCESS"] = "success";
+  SLICE_STATUS2["FAILURE"] = "failure";
+  return SLICE_STATUS2;
+})(SLICE_STATUS || {});
+var pathNameMap = {
+  "/checkout/cart": "bag",
+  "/checkout/address": "address",
+  "/checkout/payment": "payment",
+  "/checkout/summary": "summary"
+};
+var USER_CREDENTIALS = "____user_cred_";
+var USER_CART = "____user_cart_";
+var USER_CRED_TOKEN = "____user_cst_";
+var USER_CRED_REFRESH_TOKEN = "____user_csr_";
+var PRODUCT_STATUSES = [
+  "confirm",
+  "packed",
+  "shipped",
+  "delivered",
+  "cancel",
+  " return",
+  "refund"
+];
+var DEFAULT_TOAST_CONFIG = {
+  position: "bottom-left",
+  autoClose: 3e3,
+  hideProgressBar: false,
+  closeOnClick: true,
+  theme: "light",
+  progressClassName: "bg-primary"
+};
+var ALLOWED_COUNTRIES = ["AE", "IN", "US"];
+var ADDRESS_FORM_SESSION_KEY = "address_form_values";
+var _onTokenChange = null;
+function setAuthTokenChangeCallback(callback) {
+  _onTokenChange = callback;
+}
+var Auth = {
+  isAuthenticated: false,
+  getUserDetails() {
+    return typeof window === "undefined" ? false : getCookie(USER_CRED_TOKEN);
+  },
+  setUserDetails(data) {
+    setCookie(USER_CREDENTIALS, JSON.stringify(data), {
+      expires: 60,
+      path: "/"
+    });
+  },
+  setAccessToken(token) {
+    setCookie(USER_CRED_TOKEN, token, {
+      expires: 60,
+      path: "/"
+    });
+    _onTokenChange?.(token);
+  },
+  getAccessToken() {
+    return getCookie(USER_CRED_TOKEN);
+  },
+  setRefreshToken(token) {
+    setCookie(USER_CRED_REFRESH_TOKEN, token, {
+      expires: 60,
+      path: "/"
+    });
+  },
+  getRefreshToken() {
+    return getCookie(USER_CRED_REFRESH_TOKEN);
+  },
+  removeTokens() {
+    removeCookie(USER_CRED_TOKEN);
+    removeCookie(USER_CRED_REFRESH_TOKEN);
+    removeCookie(USER_CREDENTIALS);
+    _onTokenChange?.(void 0);
+  }
+};
+var auth_default = Auth;
+
+export { ADDRESS_FORM_SESSION_KEY, ALLOWED_COUNTRIES, DEFAULT_TOAST_CONFIG, PRODUCT_STATUSES, SLICE_STATUS, USER_CART, USER_CREDENTIALS, USER_CRED_REFRESH_TOKEN, USER_CRED_TOKEN, auth_default, pathNameMap, setAuthTokenChangeCallback };

package/dist/chunk-GB3HW6DM.js

@@ -0,0 +1,61 @@
+import { auth_default } from './chunk-FLBJKM6G.js';
+import { getPublicApiEndpoint, getStoreId } from './chunk-JQMLHRWL.js';
+import axios from 'axios';
+import { getCookie } from 'typescript-cookie';
+
+var _instance = null;
+function createInstance() {
+  const baseURL = getPublicApiEndpoint();
+  if (!baseURL) {
+    throw new Error("Missing API endpoint. Call initConfig() first.");
+  }
+  axios.defaults.withCredentials = true;
+  const instance = axios.create({
+    baseURL,
+    withCredentials: true
+  });
+  const onRequestSuccess = (config) => {
+    const csrftoken = getCookie("csrftoken");
+    const token = auth_default.getAccessToken();
+    config.headers["X-CSRFToken"] = csrftoken;
+    if (token) config.headers["Authorization"] = `Bearer ${token}`;
+    const storeId = 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;
+
+export { getHttpService, http_service_default, resetHttpService };

package/dist/chunk-GH75WUO2.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var chunkRCXQJ6XC_cjs = require('./chunk-RCXQJ6XC.cjs');
+var zustand = require('zustand');
+
+var initialState = {
+  cart: null,
+  status: "idle" /* IDLE */
+};
+var useCartStore = zustand.create((set) => ({
+  ...initialState,
+  setCart: (cart) => set({ cart, status: "idle" /* IDLE */ }),
+  resetCart: () => set(initialState),
+  resetCartCount: () => set((state) => {
+    if (!state.cart) return state;
+    return { cart: { ...state.cart, total_quantity: 0 } };
+  }),
+  syncCart: async () => {
+    set({ status: "loading" /* LOADING */ });
+    try {
+      const response = await chunkRCXQJ6XC_cjs.getCart("/customer/cart/");
+      if (response) {
+        set({ cart: response, status: "idle" /* IDLE */ });
+      }
+    } catch {
+      set({ status: "idle" /* IDLE */ });
+    }
+  },
+  fetchCart: async (addressId) => {
+    set({ status: "loading" /* LOADING */ });
+    try {
+      const response = await chunkRCXQJ6XC_cjs.getCart("/customer/cart/", addressId);
+      if (response) {
+        set({ cart: response, status: "idle" /* IDLE */ });
+      }
+    } catch {
+      set({ status: "idle" /* IDLE */ });
+    }
+  }
+}));
+
+exports.useCartStore = useCartStore;