shop-client 3.9.0 → 3.9.2

package/dist/chunk-MOBWPEY4.js

@@ -0,0 +1,420 @@
+import {
+  rateLimitedFetch
+} from "./chunk-2MF53V33.js";
+import {
+  formatPrice
+} from "./chunk-CN7L3BHG.js";
+
+// src/collections.ts
+import { filter, isNonNullish } from "remeda";
+function createCollectionOperations(baseUrl, storeDomain, fetchCollections, collectionsDto, fetchPaginatedProductsFromCollection, getStoreInfo, findCollection) {
+  const cacheExpiryMs = 5 * 60 * 1e3;
+  const findCache = /* @__PURE__ */ new Map();
+  const getCached = (key) => {
+    const entry = findCache.get(key);
+    if (!entry) return void 0;
+    if (Date.now() - entry.ts < cacheExpiryMs) return entry.value;
+    findCache.delete(key);
+    return void 0;
+  };
+  const setCached = (key, value) => {
+    findCache.set(key, { ts: Date.now(), value });
+  };
+  function applyCurrencyOverride(product, currency) {
+    var _a, _b, _c, _d, _e, _f;
+    const priceMin = (_b = (_a = product.priceMin) != null ? _a : product.price) != null ? _b : 0;
+    const priceMax = (_d = (_c = product.priceMax) != null ? _c : product.price) != null ? _d : 0;
+    const compareAtMin = (_f = (_e = product.compareAtPriceMin) != null ? _e : product.compareAtPrice) != null ? _f : 0;
+    return {
+      ...product,
+      currency,
+      localizedPricing: {
+        currency,
+        priceFormatted: formatPrice(priceMin, currency),
+        priceMinFormatted: formatPrice(priceMin, currency),
+        priceMaxFormatted: formatPrice(priceMax, currency),
+        compareAtPriceFormatted: formatPrice(compareAtMin, currency)
+      }
+    };
+  }
+  function maybeOverrideProductsCurrency(products, currency) {
+    if (!products || !currency) return products;
+    return products.map((p) => applyCurrencyOverride(p, currency));
+  }
+  return {
+    /**
+     * Fetches collections with pagination support.
+     *
+     * @param options - Pagination options
+     * @param options.page - Page number (default: 1)
+     * @param options.limit - Number of collections per page (default: 10, max: 250)
+     *
+     * @returns {Promise<Collection[] | null>} Collections for the requested page, or null on error
+     */
+    paginated: async (options) => {
+      var _a, _b;
+      const page = (_a = options == null ? void 0 : options.page) != null ? _a : 1;
+      const limit = (_b = options == null ? void 0 : options.limit) != null ? _b : 10;
+      if (page < 1 || limit < 1 || limit > 250) {
+        throw new Error(
+          "Invalid pagination parameters: page must be >= 1, limit must be between 1 and 250"
+        );
+      }
+      try {
+        const collections = await fetchCollections(page, limit);
+        return collections != null ? collections : null;
+      } catch (error) {
+        console.error(
+          "Failed to fetch paginated collections:",
+          storeDomain,
+          error
+        );
+        return null;
+      }
+    },
+    /**
+     * Fetches all collections from the store across all pages.
+     *
+     * @returns {Promise<Collection[]>} Array of all collections
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const allCollections = await shop.collections.all();
+     *
+     * console.log(`Found ${allCollections.length} collections`);
+     * allCollections.forEach(collection => {
+     *   console.log(collection.title, collection.handle);
+     * });
+     * ```
+     */
+    all: async () => {
+      const limit = 250;
+      const allCollections = [];
+      async function fetchAll() {
+        let currentPage = 1;
+        while (true) {
+          const collections = await fetchCollections(currentPage, limit);
+          if (!collections || collections.length === 0 || collections.length < limit) {
+            if (!collections) {
+              console.warn(
+                "fetchCollections returned null, treating as empty array."
+              );
+              break;
+            }
+            if (collections && collections.length > 0) {
+              allCollections.push(...collections);
+            }
+            break;
+          }
+          allCollections.push(...collections);
+          currentPage++;
+        }
+        return allCollections;
+      }
+      try {
+        const collections = await fetchAll();
+        return collections || [];
+      } catch (error) {
+        console.error("Failed to fetch all collections:", storeDomain, error);
+        throw error;
+      }
+    },
+    /**
+     * Finds a specific collection by its handle.
+     *
+     * @param collectionHandle - The collection handle (URL slug) to search for
+     *
+     * @returns {Promise<Collection | null>} The collection if found, null if not found
+     *
+     * @throws {Error} When the handle is invalid or there's a network error
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://example.myshopify.com');
+     * const collection = await shop.collections.find('summer-collection');
+     * if (collection) {
+     *   console.log(collection.title); // "Summer Collection"
+     * }
+     * ```
+     */
+    find: async (collectionHandle) => {
+      var _a, _b;
+      if (!collectionHandle || typeof collectionHandle !== "string") {
+        throw new Error("Collection handle is required and must be a string");
+      }
+      const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+      if (!sanitizedHandle) {
+        throw new Error("Invalid collection handle format");
+      }
+      if (sanitizedHandle.length > 255) {
+        throw new Error("Collection handle is too long");
+      }
+      const cached = getCached(sanitizedHandle);
+      if (typeof cached !== "undefined") {
+        return cached;
+      }
+      try {
+        const url = `${baseUrl}collections/${encodeURIComponent(sanitizedHandle)}.json`;
+        const response = await rateLimitedFetch(url, {
+          rateLimitClass: "collections:single"
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            return null;
+          }
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const result = await response.json();
+        let collectionImage = result.collection.image;
+        if (!collectionImage) {
+          const collectionProduct = (_a = await fetchPaginatedProductsFromCollection(
+            result.collection.handle,
+            {
+              limit: 1,
+              page: 1
+            }
+          )) == null ? void 0 : _a.at(0);
+          const collectionProductImage = (_b = collectionProduct == null ? void 0 : collectionProduct.images) == null ? void 0 : _b[0];
+          if (collectionProduct && collectionProductImage) {
+            collectionImage = {
+              id: collectionProductImage.id,
+              src: collectionProductImage.src,
+              alt: collectionProductImage.alt || collectionProduct.title,
+              created_at: collectionProductImage.createdAt || (/* @__PURE__ */ new Date()).toISOString()
+            };
+          }
+        }
+        const collectionData = collectionsDto([
+          {
+            ...result.collection,
+            image: collectionImage
+          }
+        ]);
+        const coll = collectionData[0] || null;
+        setCached(sanitizedHandle, coll);
+        if ((coll == null ? void 0 : coll.handle) && coll.handle !== sanitizedHandle) {
+          setCached(coll.handle, coll);
+        }
+        return coll;
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(
+            `Error fetching collection ${sanitizedHandle}:`,
+            baseUrl,
+            error.message
+          );
+        }
+        throw error;
+      }
+    },
+    /**
+     * Fetches collections that are showcased/featured on the store's homepage.
+     *
+     * @returns {Promise<Collection[]>} Array of showcased collections found on the homepage
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const showcasedCollections = await shop.collections.showcased();
+     *
+     * console.log(`Found ${showcasedCollections.length} showcased collections`);
+     * showcasedCollections.forEach(collection => {
+     *   console.log(`Featured: ${collection.title} - ${collection.productsCount} products`);
+     * });
+     * ```
+     */
+    showcased: async () => {
+      const storeInfo = await getStoreInfo();
+      const collections = await Promise.all(
+        storeInfo.showcase.collections.map(
+          (collectionHandle) => findCollection(collectionHandle)
+        )
+      );
+      return filter(collections, isNonNullish);
+    },
+    products: {
+      /**
+       * Fetches products from a specific collection with pagination support.
+       *
+       * @param collectionHandle - The collection handle to fetch products from
+       * @param options - Pagination options
+       * @param options.page - Page number (default: 1)
+       * @param options.limit - Number of products per page (default: 250, max: 250)
+       *
+       * @returns {Promise<Product[] | null>} Array of products from the collection or null if error occurs
+       *
+       * @throws {Error} When the collection handle is invalid or there's a network error
+       *
+       * @example
+       * ```typescript
+       * const shop = new ShopClient('https://example.myshopify.com');
+       *
+       * // Get first page of products from a collection
+       * const products = await shop.collections.products.paginated('summer-collection');
+       *
+       * // Get second page with custom limit
+       * const moreProducts = await shop.collections.products.paginated(
+       *   'summer-collection',
+       *   { page: 2, limit: 50 }
+       * );
+       * ```
+       */
+      paginated: async (collectionHandle, options) => {
+        var _a, _b;
+        if (!collectionHandle || typeof collectionHandle !== "string") {
+          throw new Error("Collection handle is required and must be a string");
+        }
+        const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid collection handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Collection handle is too long");
+        }
+        const page = (_a = options == null ? void 0 : options.page) != null ? _a : 1;
+        const limit = (_b = options == null ? void 0 : options.limit) != null ? _b : 250;
+        if (page < 1 || limit < 1 || limit > 250) {
+          throw new Error(
+            "Invalid pagination parameters: page must be >= 1, limit must be between 1 and 250"
+          );
+        }
+        const products = await fetchPaginatedProductsFromCollection(
+          sanitizedHandle,
+          { page, limit }
+        );
+        return maybeOverrideProductsCurrency(products, options == null ? void 0 : options.currency);
+      },
+      /**
+       * Fetches all products from a specific collection.
+       *
+       * @param collectionHandle - The collection handle to fetch products from
+       *
+       * @returns {Promise<Product[] | null>} Array of all products from the collection or null if error occurs
+       *
+       * @throws {Error} When the collection handle is invalid or there's a network error
+       *
+       * @example
+       * ```typescript
+       * const shop = new ShopClient('https://exampleshop.com');
+       * const allProducts = await shop.collections.products.all('summer-collection');
+       *
+       * if (allProducts) {
+       *   console.log(`Found ${allProducts.length} products in the collection`);
+       *   allProducts.forEach(product => {
+       *     console.log(`${product.title} - $${product.price}`);
+       *   });
+       * }
+       * ```
+       */
+      all: async (collectionHandle, options) => {
+        if (!collectionHandle || typeof collectionHandle !== "string") {
+          throw new Error("Collection handle is required and must be a string");
+        }
+        const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid collection handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Collection handle is too long");
+        }
+        try {
+          const limit = 250;
+          const allProducts = [];
+          let currentPage = 1;
+          while (true) {
+            const products = await fetchPaginatedProductsFromCollection(
+              sanitizedHandle,
+              {
+                page: currentPage,
+                limit
+              }
+            );
+            if (!products || products.length === 0 || products.length < limit) {
+              if (products && products.length > 0) {
+                allProducts.push(...products);
+              }
+              break;
+            }
+            allProducts.push(...products);
+            currentPage++;
+          }
+          return maybeOverrideProductsCurrency(allProducts, options == null ? void 0 : options.currency);
+        } catch (error) {
+          console.error(
+            `Error fetching all products for collection ${sanitizedHandle}:`,
+            baseUrl,
+            error
+          );
+          return null;
+        }
+      },
+      /**
+       * Fetches all product slugs from a specific collection.
+       *
+       * @param collectionHandle - The collection handle to fetch product slugs from
+       *
+       * @returns {Promise<string[] | null>} Array of product slugs from the collection or null if error occurs
+       *
+       * @throws {Error} When the collection handle is invalid or there's a network error
+       *
+       * @example
+       * ```typescript
+       * const shop = new ShopClient('https://exampleshop.com');
+       * const productSlugs = await shop.collections.products.slugs('summer-collection');
+       * console.log(productSlugs);
+       * ```
+       */
+      slugs: async (collectionHandle) => {
+        if (!collectionHandle || typeof collectionHandle !== "string") {
+          throw new Error("Collection handle is required and must be a string");
+        }
+        const sanitizedHandle = collectionHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid collection handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Collection handle is too long");
+        }
+        try {
+          const limit = 250;
+          const slugs = [];
+          let currentPage = 1;
+          while (true) {
+            const products = await fetchPaginatedProductsFromCollection(
+              sanitizedHandle,
+              {
+                page: currentPage,
+                limit
+              }
+            );
+            if (!products || products.length === 0 || products.length < limit) {
+              if (products && products.length > 0) {
+                slugs.push(...products.map((p) => p.slug));
+              }
+              break;
+            }
+            slugs.push(...products.map((p) => p.slug));
+            currentPage++;
+          }
+          return slugs;
+        } catch (error) {
+          console.error(
+            `Error fetching product slugs for collection ${sanitizedHandle}:`,
+            baseUrl,
+            error
+          );
+          return null;
+        }
+      }
+    }
+  };
+}
+
+export {
+  createCollectionOperations
+};

package/dist/chunk-QUDGES3A.js

@@ -0,0 +1,195 @@
+// src/utils/detect-country.ts
+var COUNTRY_CODES = {
+  "+1": "US",
+  // United States (primary) / Canada also uses +1
+  "+44": "GB",
+  // United Kingdom
+  "+61": "AU",
+  // Australia
+  "+65": "SG",
+  // Singapore
+  "+91": "IN",
+  // India
+  "+81": "JP",
+  // Japan
+  "+49": "DE",
+  // Germany
+  "+33": "FR",
+  // France
+  "+971": "AE",
+  // United Arab Emirates
+  "+39": "IT",
+  // Italy
+  "+34": "ES",
+  // Spain
+  "+82": "KR",
+  // South Korea
+  "+55": "BR",
+  // Brazil
+  "+62": "ID",
+  // Indonesia
+  "+92": "PK",
+  // Pakistan
+  "+7": "RU"
+  // Russia
+};
+var CURRENCY_CODE_TO_COUNTRY = {
+  INR: "IN",
+  USD: "US",
+  CAD: "CA",
+  AUD: "AU",
+  GBP: "GB",
+  EUR: "EU",
+  AED: "AE",
+  KRW: "KR",
+  JPY: "JP"
+};
+function scoreCountry(countryScores, country, weight, reason) {
+  if (!country) return;
+  if (!countryScores[country])
+    countryScores[country] = { score: 0, reasons: [] };
+  countryScores[country].score += weight;
+  countryScores[country].reasons.push(reason);
+}
+async function detectShopCountry(html) {
+  var _a;
+  const countryScores = {};
+  let detectedCurrencyCode;
+  const currencyJsonMatch = html.match(/Shopify\.currency\s*=\s*(\{[^}]*\})/);
+  if (currencyJsonMatch) {
+    try {
+      const raw = currencyJsonMatch[1];
+      const obj = JSON.parse(raw || "{}");
+      const activeCode = typeof (obj == null ? void 0 : obj.active) === "string" ? obj.active.toUpperCase() : void 0;
+      const iso = activeCode ? CURRENCY_CODE_TO_COUNTRY[activeCode] : void 0;
+      if (activeCode) {
+        detectedCurrencyCode = activeCode;
+      }
+      if (typeof iso === "string") {
+        scoreCountry(countryScores, iso, 0.8, "Shopify.currency.active");
+      }
+    } catch (_error) {
+    }
+  } else {
+    const currencyActiveAssignMatch = html.match(
+      /Shopify\.currency\.active\s*=\s*['"]([A-Za-z]{3})['"]/i
+    );
+    if (currencyActiveAssignMatch) {
+      const captured = currencyActiveAssignMatch[1];
+      const code = typeof captured === "string" ? captured.toUpperCase() : void 0;
+      const iso = code ? CURRENCY_CODE_TO_COUNTRY[code] : void 0;
+      if (code) {
+        detectedCurrencyCode = code;
+      }
+      if (typeof iso === "string") {
+        scoreCountry(countryScores, iso, 0.8, "Shopify.currency.active");
+      }
+    }
+  }
+  const shopifyCountryMatch = html.match(
+    /Shopify\.country\s*=\s*['"]([A-Za-z]{2})['"]/i
+  );
+  if (shopifyCountryMatch) {
+    const captured = shopifyCountryMatch[1];
+    const iso = typeof captured === "string" ? captured.toUpperCase() : void 0;
+    if (typeof iso === "string") {
+      scoreCountry(countryScores, iso, 1, "Shopify.country");
+    }
+  }
+  const phones = html.match(/\+\d{1,3}[\s\-()0-9]{5,}/g);
+  if (phones) {
+    for (const phone of phones) {
+      const prefix = (_a = phone.match(/^\+\d{1,3}/)) == null ? void 0 : _a[0];
+      if (prefix && COUNTRY_CODES[prefix])
+        scoreCountry(
+          countryScores,
+          COUNTRY_CODES[prefix],
+          0.8,
+          `phone prefix ${prefix}`
+        );
+    }
+  }
+  const jsonLdRegex = /<script[^>]+application\/ld\+json[^>]*>(.*?)<\/script>/g;
+  let jsonLdMatch = jsonLdRegex.exec(html);
+  while (jsonLdMatch !== null) {
+    try {
+      const json = jsonLdMatch[1];
+      if (!json) {
+      } else {
+        const raw = JSON.parse(json);
+        const collectAddressCountries = (node, results = []) => {
+          if (Array.isArray(node)) {
+            for (const item of node) collectAddressCountries(item, results);
+            return results;
+          }
+          if (node && typeof node === "object") {
+            const obj = node;
+            const address = obj.address;
+            if (address && typeof address === "object") {
+              const country = address.addressCountry;
+              if (typeof country === "string") results.push(country);
+            }
+            const graph = obj["@graph"];
+            if (graph) collectAddressCountries(graph, results);
+          }
+          return results;
+        };
+        const countries = collectAddressCountries(raw);
+        for (const country of countries) {
+          scoreCountry(countryScores, country, 1, "JSON-LD addressCountry");
+        }
+      }
+    } catch (_error) {
+    }
+    jsonLdMatch = jsonLdRegex.exec(html);
+  }
+  const footerMatch = html.match(/<footer[^>]*>(.*?)<\/footer>/i);
+  if (footerMatch) {
+    const footerTextGroup = footerMatch[1];
+    const footerText = footerTextGroup ? footerTextGroup.toLowerCase() : "";
+    const countryNameToISO = {
+      india: "IN",
+      "united states": "US",
+      canada: "CA",
+      australia: "AU",
+      "united kingdom": "GB",
+      britain: "GB",
+      uk: "GB",
+      japan: "JP",
+      "south korea": "KR",
+      korea: "KR",
+      germany: "DE",
+      france: "FR",
+      italy: "IT",
+      spain: "ES",
+      brazil: "BR",
+      russia: "RU",
+      singapore: "SG",
+      indonesia: "ID",
+      pakistan: "PK"
+    };
+    for (const [countryName, isoCode] of Object.entries(countryNameToISO)) {
+      if (footerText.includes(countryName))
+        scoreCountry(countryScores, isoCode, 0.4, "footer mention");
+    }
+  }
+  const sorted = Object.entries(countryScores).sort(
+    (a, b) => b[1].score - a[1].score
+  );
+  const best = sorted[0];
+  return best ? {
+    country: best[0],
+    confidence: Math.min(1, best[1].score / 2),
+    signals: best[1].reasons,
+    currencyCode: detectedCurrencyCode
+  } : {
+    country: "Unknown",
+    confidence: 0,
+    signals: [],
+    currencyCode: detectedCurrencyCode
+  };
+}
+
+export {
+  detectShopCountry
+};

package/dist/chunk-RR6YTQWP.js

@@ -0,0 +1,90 @@
+// src/checkout.ts
+function createCheckoutOperations(baseUrl) {
+  return {
+    /**
+     * Creates a Shopify checkout URL with pre-filled customer information and cart items.
+     *
+     * @param params - Checkout parameters
+     * @param params.email - Customer's email address (must be valid email format)
+     * @param params.items - Array of products to add to cart
+     * @param params.items[].productVariantId - Shopify product variant ID
+     * @param params.items[].quantity - Quantity as string (must be positive number)
+     * @param params.address - Customer's shipping address
+     * @param params.address.firstName - Customer's first name
+     * @param params.address.lastName - Customer's last name
+     * @param params.address.address1 - Street address
+     * @param params.address.city - City name
+     * @param params.address.zip - Postal/ZIP code
+     * @param params.address.country - Country name
+     * @param params.address.province - State/Province name
+     * @param params.address.phone - Phone number
+     *
+     * @returns {string} Complete Shopify checkout URL with pre-filled information
+     *
+     * @throws {Error} When email is invalid, items array is empty, or required address fields are missing
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const checkoutUrl = await shop.checkout.create([
+     *   { variantId: '123', quantity: 2 },
+     *   { variantId: '456', quantity: 1 }
+     * ]);
+     * console.log(checkoutUrl);
+     * ```
+     */
+    createUrl: ({
+      email,
+      items,
+      address
+    }) => {
+      if (!email || !email.includes("@")) {
+        throw new Error("Invalid email address");
+      }
+      if (!items || items.length === 0) {
+        throw new Error("Items array cannot be empty");
+      }
+      for (const item of items) {
+        if (!item.productVariantId || !item.quantity) {
+          throw new Error("Each item must have productVariantId and quantity");
+        }
+        const qty = Number.parseInt(item.quantity, 10);
+        if (Number.isNaN(qty) || qty <= 0) {
+          throw new Error("Quantity must be a positive number");
+        }
+      }
+      const requiredFields = [
+        "firstName",
+        "lastName",
+        "address1",
+        "city",
+        "zip",
+        "country"
+      ];
+      for (const field of requiredFields) {
+        if (!address[field]) {
+          throw new Error(`Address field '${field}' is required`);
+        }
+      }
+      const cartPath = items.map(
+        (item) => `${encodeURIComponent(item.productVariantId)}:${encodeURIComponent(item.quantity)}`
+      ).join(",");
+      const params = new URLSearchParams({
+        "checkout[email]": email,
+        "checkout[shipping_address][first_name]": address.firstName,
+        "checkout[shipping_address][last_name]": address.lastName,
+        "checkout[shipping_address][address1]": address.address1,
+        "checkout[shipping_address][city]": address.city,
+        "checkout[shipping_address][zip]": address.zip,
+        "checkout[shipping_address][country]": address.country,
+        "checkout[shipping_address][province]": address.province,
+        "checkout[shipping_address][phone]": address.phone
+      });
+      return `${baseUrl}cart/${cartPath}?${params.toString()}`;
+    }
+  };
+}
+
+export {
+  createCheckoutOperations
+};