@storepecker/storefront-core 1.0.0

package/dist/chunk-4CVKE6CC.cjs

@@ -0,0 +1,312 @@
+'use strict';
+
+// src/utils/cache.ts
+var DEFAULT_EXPIRY_HOURS = 24;
+var CacheManager = class _CacheManager {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.loadFromStorage();
+  }
+  static getInstance() {
+    if (!_CacheManager.instance) {
+      _CacheManager.instance = new _CacheManager();
+    }
+    return _CacheManager.instance;
+  }
+  loadFromStorage() {
+    if (typeof window === "undefined") return;
+    try {
+      const stored = localStorage.getItem("app_cache");
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        this.cache = new Map(Object.entries(parsed));
+        this.cleanExpired();
+      }
+    } catch (error) {
+      console.warn("Failed to load cache from storage:", error);
+    }
+  }
+  saveToStorage() {
+    if (typeof window === "undefined") return;
+    try {
+      const cacheObject = Object.fromEntries(this.cache);
+      localStorage.setItem("app_cache", JSON.stringify(cacheObject));
+    } catch (error) {
+      console.warn("Failed to save cache to storage:", error);
+    }
+  }
+  cleanExpired() {
+    const now = Date.now();
+    const keysToDelete = [];
+    this.cache.forEach((item, key) => {
+      if (now > item.expiry) {
+        keysToDelete.push(key);
+      }
+    });
+    keysToDelete.forEach((key) => {
+      this.cache.delete(key);
+    });
+    this.saveToStorage();
+  }
+  set(key, data, options = {}) {
+    const expiryHours = options.expiryHours || DEFAULT_EXPIRY_HOURS;
+    const now = Date.now();
+    const expiry = now + expiryHours * 60 * 60 * 1e3;
+    const cacheItem = {
+      data,
+      timestamp: now,
+      expiry
+    };
+    this.cache.set(key, cacheItem);
+    this.saveToStorage();
+  }
+  get(key) {
+    this.cleanExpired();
+    const item = this.cache.get(key);
+    if (!item) return null;
+    const now = Date.now();
+    if (now > item.expiry) {
+      this.cache.delete(key);
+      this.saveToStorage();
+      return null;
+    }
+    return item.data;
+  }
+  has(key) {
+    this.cleanExpired();
+    return this.cache.has(key);
+  }
+  delete(key) {
+    this.cache.delete(key);
+    this.saveToStorage();
+  }
+  clear() {
+    this.cache.clear();
+    if (typeof window !== "undefined") {
+      localStorage.removeItem("app_cache");
+    }
+  }
+  getCacheInfo() {
+    this.cleanExpired();
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+  invalidateCache(pattern) {
+    this.cleanExpired();
+    if (!pattern) {
+      this.clear();
+      return;
+    }
+    const keysToDelete = [];
+    this.cache.forEach((item, key) => {
+      if (key.includes(pattern)) {
+        keysToDelete.push(key);
+      }
+    });
+    keysToDelete.forEach((key) => {
+      this.cache.delete(key);
+    });
+    this.saveToStorage();
+  }
+};
+var cache = CacheManager.getInstance();
+function setCache(key, data, options = {}) {
+  cache.set(key, data, options);
+}
+function getCache(key) {
+  return cache.get(key);
+}
+function hasCache(key) {
+  return cache.has(key);
+}
+function deleteCache(key) {
+  cache.delete(key);
+}
+function clearCache() {
+  cache.clear();
+}
+function invalidateCache(pattern) {
+  cache.invalidateCache(pattern);
+}
+function generateCacheKey(endpoint, params) {
+  const baseKey = endpoint.replace(/[^a-zA-Z0-9]/g, "_");
+  if (!params) return baseKey;
+  const paramString = JSON.stringify(params);
+  const hash = btoa(paramString).replace(/[^a-zA-Z0-9]/g, "");
+  return `${baseKey}_${hash}`;
+}
+
+// src/utils/misc.ts
+function convertObjectToParams(params) {
+  const cleanedParams = Object.fromEntries(
+    Object.entries(params).filter(([_, value]) => value !== void 0)
+  );
+  const searchParams = new URLSearchParams(cleanedParams);
+  return searchParams.toString();
+}
+function getParamsFromURL() {
+  if (typeof window === "undefined") return {};
+  const queryParams = {};
+  const search = window.location.search;
+  const searchParams = new URLSearchParams(search);
+  searchParams.forEach((value, key) => {
+    if (value.includes(",")) {
+      queryParams[key] = value.split(",");
+    } else if (isNaN(Number(value))) {
+      queryParams[key] = value;
+    } else queryParams[key] = Number(value);
+  });
+  return queryParams;
+}
+function pushParamsToURL(params) {
+  const cleanedParams = Object.fromEntries(
+    Object.entries(params).filter(([_, value]) => {
+      return Array.isArray(value) ? value.length : !(value === void 0 || value === 0);
+    })
+  );
+  const searchParams = new URLSearchParams(cleanedParams);
+  return searchParams.toString();
+}
+function convertToCurrency(amount, fraction = 0, currency) {
+  return amount?.toLocaleString("en-IN", {
+    style: "currency",
+    currency: currency || (typeof window !== "undefined" ? window.currency_code : void 0) || "INR",
+    maximumFractionDigits: fraction
+  });
+}
+function formatDateTime(date) {
+  return new Date(date).toLocaleString("en-IN", {
+    dateStyle: "medium"
+  });
+}
+var getQueryParams = (params, filterKeys = []) => {
+  let filterParams = params;
+  Object.keys(filterParams).forEach((key) => {
+    const value = filterParams[key];
+    if (!value) {
+      delete filterParams[key];
+    }
+    if (filterKeys.includes(key)) {
+      if (value && !Array.isArray(value)) {
+        filterParams[key] = value.toString()?.split(",");
+      }
+    }
+  });
+  return filterParams;
+};
+var shareLink = (shareData, title, url) => {
+  if (navigator.share) {
+    navigator.share({
+      title: "Storepecker",
+      text: shareData,
+      url: url || window.location.href
+    });
+  } else {
+    navigator.clipboard.writeText(window.location.href);
+  }
+};
+function pluralize(strings, count, singular, plural) {
+  const word = count === 1 ? singular : plural;
+  return `${strings[0]}${count} ${word}${strings[1]}`;
+}
+async function digestMessage(message) {
+  const msgUint8 = new TextEncoder().encode(message);
+  const hashBuffer = await window.crypto.subtle.digest("SHA-256", msgUint8);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+var constructFilter = (filter) => {
+  if (filter) {
+    const filtersObj = {};
+    filter.forEach((filter2) => {
+      if (filtersObj[filter2.type]) {
+        if (Array.isArray(filter2.value)) {
+          filtersObj[filter2.type] = filtersObj[filter2.type] + "," + filter2.value.join(",");
+        } else {
+          filtersObj[filter2.type] = filtersObj[filter2.type] + "," + filter2.value;
+        }
+      } else {
+        filtersObj[filter2.type] = Array.isArray(filter2.value) ? filter2.value.join(",") : filter2.value;
+      }
+    });
+    return filtersObj;
+  }
+  return {};
+};
+var getDelayInMilliseconds = (value, unit) => {
+  switch (unit) {
+    case "seconds":
+      return value * 1e3;
+    case "minutes":
+      return value * 60 * 1e3;
+    case "hours":
+      return value * 60 * 60 * 1e3;
+    case "days":
+      return value * 24 * 60 * 60 * 1e3;
+    case "weeks":
+      return value * 7 * 24 * 60 * 60 * 1e3;
+    case "months":
+      return value * 30 * 24 * 60 * 60 * 1e3;
+    default:
+      return value * 1e3;
+  }
+};
+function formatPostalLabel(zipNameType) {
+  if (!zipNameType) return "";
+  const t = zipNameType.toLowerCase();
+  switch (t) {
+    case "zip":
+      return "ZIP Code";
+    case "pin":
+      return "PIN Code";
+    case "postal":
+      return "Postal Code";
+    case "post":
+      return "Postcode";
+    case "eir":
+      return "Eircode";
+    case "cep":
+      return "CEP";
+    case "cap":
+      return "CAP";
+    default:
+      return t.charAt(0).toUpperCase() + t.slice(1);
+  }
+}
+async function getAddressMeta(countryCode) {
+  const res = await fetch(
+    `https://chromium-i18n.appspot.com/ssl-address/data/${countryCode}`
+  );
+  const data = await res.json();
+  return {
+    regionLabel: data.state_name_type || "State",
+    postalLabel: formatPostalLabel(data.zip_name_type) || "Postal Code",
+    hasPostal: !!data.zip_name_type
+  };
+}
+
+exports.CacheManager = CacheManager;
+exports.cache = cache;
+exports.clearCache = clearCache;
+exports.constructFilter = constructFilter;
+exports.convertObjectToParams = convertObjectToParams;
+exports.convertToCurrency = convertToCurrency;
+exports.deleteCache = deleteCache;
+exports.digestMessage = digestMessage;
+exports.formatDateTime = formatDateTime;
+exports.formatPostalLabel = formatPostalLabel;
+exports.generateCacheKey = generateCacheKey;
+exports.getAddressMeta = getAddressMeta;
+exports.getCache = getCache;
+exports.getDelayInMilliseconds = getDelayInMilliseconds;
+exports.getParamsFromURL = getParamsFromURL;
+exports.getQueryParams = getQueryParams;
+exports.hasCache = hasCache;
+exports.invalidateCache = invalidateCache;
+exports.pluralize = pluralize;
+exports.pushParamsToURL = pushParamsToURL;
+exports.setCache = setCache;
+exports.shareLink = shareLink;

package/dist/chunk-4MJMNIAB.js

@@ -0,0 +1,123 @@
+import { http_service_default } from './chunk-GB3HW6DM.js';
+
+// src/api/coupon.ts
+async function getCoupons() {
+  return http_service_default.get("/coupon/available/");
+}
+async function applyCoupon(couponCode) {
+  return http_service_default.post("/coupon/use/", { coupon_code: couponCode });
+}
+async function getAppliedCoupon() {
+  return http_service_default.get("/coupon/use/");
+}
+async function removeCoupon(couponCode) {
+  return http_service_default.delete("/coupon/use/");
+}
+
+// src/api/orders.ts
+async function getOrders(url) {
+  const response = await http_service_default.get(url);
+  return response.data;
+}
+async function getOrderDetails(orderId) {
+  return http_service_default.get("/customer/order/", {
+    params: { order_id: orderId }
+  });
+}
+async function getOrderDetailsByNumber(orderNumber) {
+  return http_service_default.get("/customer/order/", {
+    params: { order_number: orderNumber }
+  });
+}
+async function getPublicOrderDetailsByNumber(orderNumber) {
+  return http_service_default.get("/customer/public_order/", {
+    params: { order_number: orderNumber }
+  });
+}
+async function placeOrder(address_id, redirect, isCod, stripeRedirect, tabbyRedirect) {
+  return 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 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 http_service_default.patch("/customer/order/", orderDetails);
+}
+async function razorpayPublicOrderSuccess(orderDetails) {
+  return http_service_default.post("/payment/public-razorpay-order-success/", orderDetails);
+}
+async function razorpayOrderSuccess(orderDetails) {
+  return http_service_default.post("/payment/razorpay-order-success/", orderDetails);
+}
+async function razorpayOrderFail(orderDetails) {
+  return http_service_default.post("/payment/razorpay-order-fail/", orderDetails);
+}
+async function phonepePublicOrderSuccess(orderDetails) {
+  return http_service_default.post("/payment/public-phonepe-order-success/", orderDetails);
+}
+async function phonepeOrderSuccess(orderDetails) {
+  return http_service_default.post("/payment/phonepe-order-success/", orderDetails);
+}
+async function checkPhonepePaymentStatus(transactionId) {
+  return http_service_default.get("/payment/phonepe-order-success/", {
+    params: { phonepe_transaction_id: transactionId }
+  });
+}
+async function getStripePaymentStatus(stripeCheckoutSessionId, order_number, payment_link_id) {
+  return 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 http_service_default.get("/payment/public-stripe-payment-status/", {
+    params: {
+      checkout_session_id: stripeCheckoutSessionId,
+      order_number,
+      payment_link_id
+    }
+  });
+}
+async function stripePublicOrderSuccess(orderDetails) {
+  return http_service_default.post("/payment/public-stripe-order-success/", orderDetails);
+}
+async function stripeOrderSuccess(orderDetails) {
+  return http_service_default.post("/payment/stripe-order-success/", orderDetails);
+}
+async function stripeOrderFail(orderDetails) {
+  return http_service_default.post("/payment/stripe-order-fail/", orderDetails);
+}
+async function makeCODOrder(orderId) {
+  return http_service_default.post("/customer/order_cod/", { order_id: orderId });
+}
+async function publicMakeCODOrder(orderNumber) {
+  return http_service_default.post("/customer/public_order_cod/", { order_number: orderNumber });
+}
+async function updateOrderCustomization(customizationInput) {
+  return http_service_default.post("/customer/product_personalize/", customizationInput);
+}
+async function uploadCustomizationImage(uploadForm) {
+  return http_service_default.post("/utils/upload_image", uploadForm);
+}
+async function verifyTabbyPayment(orderNumber) {
+  return http_service_default.get("/payment/tabby-payment-status/", {
+    params: { order_number: orderNumber }
+  });
+}
+
+export { applyCoupon, checkPhonepePaymentStatus, getAppliedCoupon, getCoupons, getOrderDetails, getOrderDetailsByNumber, getOrders, getPublicOrderDetailsByNumber, getStripePaymentStatus, getStripePaymentStatusPublic, makeCODOrder, phonepeOrderSuccess, phonepePublicOrderSuccess, placeOrder, publicMakeCODOrder, publicPlaceOrder, razorpayOrderFail, razorpayOrderSuccess, razorpayPublicOrderSuccess, removeCoupon, stripeOrderFail, stripeOrderSuccess, stripePublicOrderSuccess, updateOrder, updateOrderCustomization, uploadCustomizationImage, verifyTabbyPayment };

package/dist/chunk-57ZBPAXU.js

@@ -0,0 +1,114 @@
+import { cart_default } from './chunk-E7WPE3PV.js';
+import { http_service_default } from './chunk-GB3HW6DM.js';
+import { auth_default } from './chunk-FLBJKM6G.js';
+
+// src/api/cart.ts
+async function getCart(url, addressId) {
+  const localCart = cart_default.get();
+  return auth_default.getUserDetails() ? (await 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 http_service_default.post("/customer/cart/", {
+    action: "add",
+    cart_items: product,
+    customization_inputs: customizationInputs
+  });
+}
+async function removeFromCart(product) {
+  return http_service_default.post("/customer/cart/", {
+    action: "remove",
+    cart_items: product
+  });
+}
+async function updateCart(product) {
+  return http_service_default.post("/customer/cart/", {
+    action: "update",
+    cart_items: product
+  });
+}
+
+// src/api/product.ts
+async function getProductList(url, filter) {
+  const response = await http_service_default.get(url, {
+    params: filter
+  });
+  return response.data;
+}
+async function getProducts(filter) {
+  return http_service_default.get("/inventory/products/", {
+    params: { ...filter }
+  });
+}
+async function getProductDetail(url, slug) {
+  const response = await http_service_default.get(url, {
+    params: { variant_slug: slug }
+  });
+  return response.data;
+}
+async function getProductCategories(url) {
+  return await http_service_default.get(url);
+}
+async function getDigitalProductDownloadLink(variantId) {
+  return http_service_default.get("/inventory/digital_product/download/", {
+    params: { variant_id: variantId }
+  });
+}
+async function updateDigitalProductDownloadLinkCount(variantId, downloadLink) {
+  return http_service_default.post("/inventory/digital_product/download/", {
+    variant_id: variantId,
+    download_link: downloadLink
+  });
+}
+async function getCategories(responseType = "flat") {
+  return await http_service_default.get("/inventory/categories/", {
+    params: { response_structure: responseType }
+  });
+}
+async function getProductDetailBySlug(url, slug) {
+  const response = await 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 http_service_default.post("/utils/customer/notify-me/", userDetails);
+}
+
+// src/api/wishlist.ts
+async function getWishlist(url) {
+  const response = await http_service_default.get(url);
+  return response.data;
+}
+async function addWishlist(productDetails) {
+  return http_service_default.post("/customer/wishlist/", productDetails);
+}
+async function removeFromWishlist(product_variants) {
+  return http_service_default.post("/customer/wishlist/", {
+    action: "remove",
+    product_variants
+  });
+}
+
+export { addToCart, addWishlist, getCart, getCategories, getDigitalProductDownloadLink, getProductCategories, getProductDetail, getProductDetailBySlug, getProductList, getProducts, getWishlist, notifyProductStock, removeFromCart, removeFromWishlist, updateCart, updateDigitalProductDownloadLinkCount };

package/dist/chunk-7MQOVWLW.js

@@ -0,0 +1,40 @@
+import { getCart } from './chunk-57ZBPAXU.js';
+import { create } from 'zustand';
+
+var initialState = {
+  cart: null,
+  status: "idle" /* IDLE */
+};
+var useCartStore = 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 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 getCart("/customer/cart/", addressId);
+      if (response) {
+        set({ cart: response, status: "idle" /* IDLE */ });
+      }
+    } catch {
+      set({ status: "idle" /* IDLE */ });
+    }
+  }
+}));
+
+export { useCartStore };

package/dist/chunk-7UH6REGV.js

@@ -0,0 +1,12 @@
+import { http_service_default } from './chunk-GB3HW6DM.js';
+
+// src/api/user.ts
+async function getUserDetails(url) {
+  const response = await http_service_default.get(url);
+  return response.data;
+}
+async function updateUserDetails(userDetails) {
+  return http_service_default.patch("/users/store/profile/", { ...userDetails });
+}
+
+export { getUserDetails, updateUserDetails };