shop-client 3.9.0 → 3.9.2

package/dist/chunk-CXUCPK6X.js

@@ -0,0 +1,460 @@
+import {
+  rateLimitedFetch
+} from "./chunk-2MF53V33.js";
+import {
+  formatPrice
+} from "./chunk-CN7L3BHG.js";
+
+// src/products.ts
+import { filter, isNonNullish } from "remeda";
+function createProductOperations(baseUrl, storeDomain, fetchProducts, productsDto, productDto, getStoreInfo, findProduct) {
+  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));
+  }
+  const operations = {
+    /**
+     * Fetches all products from the store across all pages.
+     *
+     * @returns {Promise<Product[] | null>} Array of all products or null if error occurs
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const allProducts = await shop.products.all();
+     *
+     * console.log(`Found ${allProducts?.length} products`);
+     * allProducts?.forEach(product => {
+     *   console.log(product.title, product.price);
+     * });
+     * ```
+     */
+    all: async (options) => {
+      const limit = 250;
+      const allProducts = [];
+      async function fetchAll() {
+        let currentPage = 1;
+        while (true) {
+          const products = await fetchProducts(currentPage, limit);
+          if (!products || products.length === 0 || products.length < limit) {
+            if (products && products.length > 0) {
+              allProducts.push(...products);
+            }
+            break;
+          }
+          allProducts.push(...products);
+          currentPage++;
+        }
+        return allProducts;
+      }
+      try {
+        const products = await fetchAll();
+        return maybeOverrideProductsCurrency(products, options == null ? void 0 : options.currency);
+      } catch (error) {
+        console.error("Failed to fetch all products:", storeDomain, error);
+        throw error;
+      }
+    },
+    /**
+     * Fetches products with pagination support.
+     *
+     * @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 for the specified page or null if error occurs
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://example.myshopify.com');
+     *
+     * // Get first page with default limit (250)
+     * const firstPage = await shop.products.paginated();
+     *
+     * // Get second page with custom limit
+     * const secondPage = await shop.products.paginated({ page: 2, limit: 50 });
+     * ```
+     */
+    paginated: async (options) => {
+      var _a, _b;
+      const page = (_a = options == null ? void 0 : options.page) != null ? _a : 1;
+      const limit = Math.min((_b = options == null ? void 0 : options.limit) != null ? _b : 250, 250);
+      const url = `${baseUrl}products.json?limit=${limit}&page=${page}`;
+      try {
+        const response = await rateLimitedFetch(url, {
+          rateLimitClass: "products:paginated"
+        });
+        if (!response.ok) {
+          console.error(
+            `HTTP error! status: ${response.status} for ${storeDomain} page ${page}`
+          );
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        if (data.products.length === 0) {
+          return [];
+        }
+        const normalized = productsDto(data.products);
+        return maybeOverrideProductsCurrency(normalized, options == null ? void 0 : options.currency);
+      } catch (error) {
+        console.error(
+          `Error fetching products for ${storeDomain} page ${page} with limit ${limit}:`,
+          error
+        );
+        return null;
+      }
+    },
+    /**
+     * Finds a specific product by its handle.
+     *
+     * @param productHandle - The product handle (URL slug) to search for
+     *
+     * @returns {Promise<Product | null>} The product 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://exampleshop.com');
+     *
+     * // Find product by handle
+     * const product = await shop.products.find('awesome-t-shirt');
+     *
+     * if (product) {
+     *   console.log(product.title, product.price);
+     *   console.log('Available variants:', product.variants.length);
+     * }
+     *
+     * // Handle with query string
+     * const productWithVariant = await shop.products.find('t-shirt?variant=123');
+     * ```
+     */
+    find: async (productHandle, options) => {
+      var _a, _b;
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      try {
+        let qs = null;
+        if (productHandle.includes("?")) {
+          const parts = productHandle.split("?");
+          const handlePart = (_a = parts[0]) != null ? _a : productHandle;
+          const qsPart = (_b = parts[1]) != null ? _b : null;
+          productHandle = handlePart;
+          qs = qsPart;
+        }
+        const sanitizedHandle = productHandle.trim().replace(/[^a-zA-Z0-9\-_]/g, "");
+        if (!sanitizedHandle) {
+          throw new Error("Invalid product handle format");
+        }
+        if (sanitizedHandle.length > 255) {
+          throw new Error("Product handle is too long");
+        }
+        const cached = getCached(sanitizedHandle);
+        if (typeof cached !== "undefined") {
+          return (options == null ? void 0 : options.currency) ? cached ? applyCurrencyOverride(cached, options.currency) : null : cached;
+        }
+        let finalHandle = sanitizedHandle;
+        try {
+          const htmlResp = await rateLimitedFetch(
+            `${baseUrl}products/${encodeURIComponent(sanitizedHandle)}`,
+            { rateLimitClass: "products:resolve" }
+          );
+          if (htmlResp.ok) {
+            const finalUrl = htmlResp.url;
+            if (finalUrl) {
+              const pathname = new URL(finalUrl).pathname.replace(/\/$/, "");
+              const parts = pathname.split("/").filter(Boolean);
+              const idx = parts.indexOf("products");
+              const maybeHandle = idx >= 0 ? parts[idx + 1] : void 0;
+              if (typeof maybeHandle === "string" && maybeHandle.length) {
+                finalHandle = maybeHandle;
+              }
+            }
+          }
+        } catch {
+        }
+        const url = `${baseUrl}products/${encodeURIComponent(finalHandle)}.js${qs ? `?${qs}` : ""}`;
+        const response = await rateLimitedFetch(url, {
+          rateLimitClass: "products:single"
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            return null;
+          }
+          throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const product = await response.json();
+        const productData = productDto(product);
+        setCached(sanitizedHandle, productData);
+        if (finalHandle !== sanitizedHandle)
+          setCached(finalHandle, productData);
+        return (options == null ? void 0 : options.currency) ? applyCurrencyOverride(productData, options.currency) : productData;
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(
+            `Error fetching product ${productHandle}:`,
+            baseUrl,
+            error.message
+          );
+        }
+        throw error;
+      }
+    },
+    /**
+     * Enrich a product by generating merged markdown from body_html and product page.
+     * Adds `enriched_content` to the returned product.
+     */
+    enriched: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const apiKey = (options == null ? void 0 : options.apiKey) || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Missing OpenRouter API key. Pass options.apiKey or set OPENROUTER_API_KEY."
+        );
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) {
+        return null;
+      }
+      const handle = baseProduct.handle;
+      const { enrichProduct } = await import("./ai/enrich.js");
+      const enriched = await enrichProduct(storeDomain, handle, {
+        apiKey,
+        useGfm: options == null ? void 0 : options.useGfm,
+        inputType: options == null ? void 0 : options.inputType,
+        model: options == null ? void 0 : options.model,
+        outputFormat: options == null ? void 0 : options.outputFormat
+      });
+      return {
+        ...baseProduct,
+        enriched_content: enriched.mergedMarkdown
+      };
+    },
+    classify: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const apiKey = (options == null ? void 0 : options.apiKey) || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Missing OpenRouter API key. Pass options.apiKey or set OPENROUTER_API_KEY."
+        );
+      }
+      const enrichedProduct = await operations.enriched(productHandle, {
+        apiKey,
+        inputType: "html",
+        model: options == null ? void 0 : options.model,
+        outputFormat: "json"
+      });
+      if (!enrichedProduct || !enrichedProduct.enriched_content) return null;
+      let productContent = enrichedProduct.enriched_content;
+      try {
+        const obj = JSON.parse(enrichedProduct.enriched_content);
+        const lines = [];
+        if (obj.title && typeof obj.title === "string")
+          lines.push(`Title: ${obj.title}`);
+        if (obj.description && typeof obj.description === "string")
+          lines.push(`Description: ${obj.description}`);
+        if (Array.isArray(obj.materials) && obj.materials.length)
+          lines.push(`Materials: ${obj.materials.join(", ")}`);
+        if (Array.isArray(obj.care) && obj.care.length)
+          lines.push(`Care: ${obj.care.join(", ")}`);
+        if (obj.fit && typeof obj.fit === "string")
+          lines.push(`Fit: ${obj.fit}`);
+        if (obj.returnPolicy && typeof obj.returnPolicy === "string")
+          lines.push(`ReturnPolicy: ${obj.returnPolicy}`);
+        productContent = lines.join("\n");
+      } catch {
+      }
+      const { classifyProduct } = await import("./ai/enrich.js");
+      const classification = await classifyProduct(productContent, {
+        apiKey,
+        model: options == null ? void 0 : options.model
+      });
+      return classification;
+    },
+    generateSEOContent: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const apiKey = (options == null ? void 0 : options.apiKey) || process.env.OPENROUTER_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "Missing OpenRouter API key. Pass options.apiKey or set OPENROUTER_API_KEY."
+        );
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) return null;
+      const payload = {
+        title: baseProduct.title,
+        description: baseProduct.bodyHtml || void 0,
+        vendor: baseProduct.vendor,
+        price: baseProduct.price,
+        tags: baseProduct.tags
+      };
+      const { generateSEOContent: generateSEOContentLLM } = await import("./ai/enrich.js");
+      const seo = await generateSEOContentLLM(payload, {
+        apiKey,
+        model: options == null ? void 0 : options.model
+      });
+      return seo;
+    },
+    /**
+     * Fetches products that are showcased/featured on the store's homepage.
+     *
+     * @returns {Promise<Product[]>} Array of showcased products 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 showcasedProducts = await shop.products.showcased();
+     *
+     * console.log(`Found ${showcasedProducts.length} showcased products`);
+     * showcasedProducts.forEach(product => {
+     *   console.log(`Featured: ${product.title} - ${product.price}`);
+     * });
+     * ```
+     */
+    showcased: async () => {
+      const storeInfo = await getStoreInfo();
+      const products = await Promise.all(
+        storeInfo.showcase.products.map(
+          (productHandle) => findProduct(productHandle)
+        )
+      );
+      return filter(products, isNonNullish);
+    },
+    /**
+     * Creates a filter map of variant options and their distinct values from all products.
+     *
+     * @returns {Promise<Record<string, string[]> | null>} Map of option names to their distinct values or null if error occurs
+     *
+     * @throws {Error} When there's a network error or API failure
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const filters = await shop.products.filter();
+     *
+     * console.log('Available filters:', filters);
+     * // Output: { "Size": ["S", "M", "L", "XL"], "Color": ["Red", "Blue", "Green"] }
+     *
+     * // Use filters for UI components
+     * Object.entries(filters || {}).forEach(([optionName, values]) => {
+     *   console.log(`${optionName}: ${values.join(', ')}`);
+     * });
+     * ```
+     */
+    filter: async () => {
+      try {
+        const products = await operations.all();
+        if (!products || products.length === 0) {
+          return {};
+        }
+        const filterMap = {};
+        products.forEach((product) => {
+          if (product.variants && product.variants.length > 0) {
+            if (product.options && product.options.length > 0) {
+              product.options.forEach((option) => {
+                const lowercaseOptionName = option.name.toLowerCase();
+                if (!filterMap[lowercaseOptionName]) {
+                  filterMap[lowercaseOptionName] = /* @__PURE__ */ new Set();
+                }
+                option.values.forEach((value) => {
+                  const trimmed = value == null ? void 0 : value.trim();
+                  if (trimmed) {
+                    let set = filterMap[lowercaseOptionName];
+                    if (!set) {
+                      set = /* @__PURE__ */ new Set();
+                      filterMap[lowercaseOptionName] = set;
+                    }
+                    set.add(trimmed.toLowerCase());
+                  }
+                });
+              });
+            }
+            product.variants.forEach((variant) => {
+              var _a, _b, _c, _d, _e, _f;
+              if (variant.option1) {
+                const optionName = (((_b = (_a = product.options) == null ? void 0 : _a[0]) == null ? void 0 : _b.name) || "Option 1").toLowerCase();
+                let set1 = filterMap[optionName];
+                if (!set1) {
+                  set1 = /* @__PURE__ */ new Set();
+                  filterMap[optionName] = set1;
+                }
+                set1.add(variant.option1.trim().toLowerCase());
+              }
+              if (variant.option2) {
+                const optionName = (((_d = (_c = product.options) == null ? void 0 : _c[1]) == null ? void 0 : _d.name) || "Option 2").toLowerCase();
+                let set2 = filterMap[optionName];
+                if (!set2) {
+                  set2 = /* @__PURE__ */ new Set();
+                  filterMap[optionName] = set2;
+                }
+                set2.add(variant.option2.trim().toLowerCase());
+              }
+              if (variant.option3) {
+                const optionName = (((_f = (_e = product.options) == null ? void 0 : _e[2]) == null ? void 0 : _f.name) || "Option 3").toLowerCase();
+                if (!filterMap[optionName]) {
+                  filterMap[optionName] = /* @__PURE__ */ new Set();
+                }
+                filterMap[optionName].add(variant.option3.trim().toLowerCase());
+              }
+            });
+          }
+        });
+        const result = {};
+        Object.entries(filterMap).forEach(([optionName, valueSet]) => {
+          result[optionName] = Array.from(valueSet).sort();
+        });
+        return result;
+      } catch (error) {
+        console.error("Failed to create product filters:", storeDomain, error);
+        throw error;
+      }
+    }
+  };
+  return operations;
+}
+
+export {
+  createProductOperations
+};

package/dist/chunk-DJQEZNHG.js

@@ -0,0 +1,233 @@
+import {
+  rateLimitedFetch
+} from "./chunk-2MF53V33.js";
+import {
+  detectShopCountry
+} from "./chunk-QUDGES3A.js";
+import {
+  extractDomainWithoutSuffix,
+  generateStoreSlug,
+  sanitizeDomain
+} from "./chunk-CN7L3BHG.js";
+
+// src/client/get-info.ts
+import { unique } from "remeda";
+async function getInfoForStore(args) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  const {
+    baseUrl,
+    storeDomain,
+    validateProductExists,
+    validateCollectionExists,
+    validateLinksInBatches
+  } = args;
+  const response = await rateLimitedFetch(baseUrl, {
+    rateLimitClass: "store:info"
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  const html = await response.text();
+  const getMetaTag = (name2) => {
+    const regex = new RegExp(
+      `<meta[^>]*name=["']${name2}["'][^>]*content=["'](.*?)["']`
+    );
+    const match = html.match(regex);
+    return match ? match[1] : null;
+  };
+  const getPropertyMetaTag = (property) => {
+    const regex = new RegExp(
+      `<meta[^>]*property=["']${property}["'][^>]*content=["'](.*?)["']`
+    );
+    const match = html.match(regex);
+    return match ? match[1] : null;
+  };
+  const name = (_a = getMetaTag("og:site_name")) != null ? _a : extractDomainWithoutSuffix(baseUrl);
+  const title = (_b = getMetaTag("og:title")) != null ? _b : getMetaTag("twitter:title");
+  const description = getMetaTag("description") || getPropertyMetaTag("og:description");
+  const shopifyWalletId = (_c = getMetaTag("shopify-digital-wallet")) == null ? void 0 : _c.split("/")[1];
+  const myShopifySubdomainMatch = html.match(/['"](.*?\.myshopify\.com)['"]/);
+  const myShopifySubdomain = myShopifySubdomainMatch ? myShopifySubdomainMatch[1] : null;
+  let logoUrl = getPropertyMetaTag("og:image") || getPropertyMetaTag("og:image:secure_url");
+  if (!logoUrl) {
+    const logoMatch = html.match(
+      /<img[^>]+src=["']([^"']+\/cdn\/shop\/[^"']+)["']/
+    );
+    const matchedUrl = logoMatch == null ? void 0 : logoMatch[1];
+    logoUrl = matchedUrl ? matchedUrl.replace("http://", "https://") : null;
+  } else {
+    logoUrl = logoUrl.replace("http://", "https://");
+  }
+  const socialLinks = {};
+  const socialRegex = /<a[^>]+href=["']([^"']*(?:facebook|twitter|instagram|pinterest|youtube|linkedin|tiktok|vimeo)\.com[^"']*)["']/g;
+  for (const match of html.matchAll(socialRegex)) {
+    const str = match[1];
+    if (!str) continue;
+    let href = str;
+    try {
+      if (href.startsWith("//")) {
+        href = `https:${href}`;
+      } else if (href.startsWith("/")) {
+        href = new URL(href, baseUrl).toString();
+      }
+      const parsed = new URL(href);
+      const domain = parsed.hostname.replace("www.", "").split(".")[0];
+      if (domain) {
+        socialLinks[domain] = parsed.toString();
+      }
+    } catch {
+    }
+  }
+  const contactLinks = {
+    tel: null,
+    email: null,
+    contactPage: null
+  };
+  for (const match of html.matchAll(/href=["']tel:([^"']+)["']/g)) {
+    contactLinks.tel = ((_d = match == null ? void 0 : match[1]) == null ? void 0 : _d.trim()) || null;
+  }
+  for (const match of html.matchAll(/href=["']mailto:([^"']+)["']/g)) {
+    contactLinks.email = ((_e = match == null ? void 0 : match[1]) == null ? void 0 : _e.trim()) || null;
+  }
+  for (const match of html.matchAll(
+    /href=["']([^"']*(?:\/contact|\/pages\/contact)[^"']*)["']/g
+  )) {
+    contactLinks.contactPage = (match == null ? void 0 : match[1]) || null;
+  }
+  const extractedProductLinks = ((_g = (_f = html.match(/href=["']([^"']*\/products\/[^"']+)["']/g)) == null ? void 0 : _f.map(
+    (match) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = match == null ? void 0 : match.split("href=")[1]) == null ? void 0 : _a2.replace(/["']/g, "")) == null ? void 0 : _b2.split("/").at(-1);
+    }
+  )) == null ? void 0 : _g.filter(Boolean)) || [];
+  const extractedCollectionLinks = ((_i = (_h = html.match(/href=["']([^"']*\/collections\/[^"']+)["']/g)) == null ? void 0 : _h.map(
+    (match) => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = match == null ? void 0 : match.split("href=")[1]) == null ? void 0 : _a2.replace(/["']/g, "")) == null ? void 0 : _b2.split("/").at(-1);
+    }
+  )) == null ? void 0 : _i.filter(Boolean)) || [];
+  const headerLinks = (_k = (_j = html.match(
+    /<(header|nav|div|section)\b[^>]*\b(?:id|class)=["'][^"']*(?=.*shopify-section)(?=.*\b(header|navigation|nav|menu)\b)[^"']*["'][^>]*>[\s\S]*?<\/\1>/gi
+  )) == null ? void 0 : _j.flatMap((header) => {
+    var _a2, _b2;
+    const links = (_a2 = header.match(/href=["']([^"']+)["']/g)) == null ? void 0 : _a2.filter(
+      (link) => link.includes("/products/") || link.includes("/collections/") || link.includes("/pages/")
+    );
+    return (_b2 = links == null ? void 0 : links.map((link) => {
+      var _a3;
+      const href = (_a3 = link.match(/href=["']([^"']+)["']/)) == null ? void 0 : _a3[1];
+      if (href && !href.startsWith("#") && !href.startsWith("javascript:")) {
+        try {
+          const url = new URL(href, storeDomain);
+          return url.pathname.replace(/^\/|\/$/g, "");
+        } catch {
+          return href.replace(/^\/|\/$/g, "");
+        }
+      }
+      return null;
+    }).filter((item) => Boolean(item))) != null ? _b2 : [];
+  })) != null ? _k : [];
+  const slug = generateStoreSlug(baseUrl);
+  const countryDetection = await detectShopCountry(html);
+  const [homePageProductLinks, homePageCollectionLinks] = await Promise.all([
+    validateLinksInBatches(
+      extractedProductLinks.filter(
+        (handle) => Boolean(handle)
+      ),
+      (handle) => validateProductExists(handle)
+    ),
+    validateLinksInBatches(
+      extractedCollectionLinks.filter(
+        (handle) => Boolean(handle)
+      ),
+      (handle) => validateCollectionExists(handle)
+    )
+  ]);
+  const info = {
+    name: name || slug,
+    domain: sanitizeDomain(baseUrl),
+    slug,
+    title: title || null,
+    description: description || null,
+    logoUrl,
+    socialLinks,
+    contactLinks,
+    headerLinks,
+    showcase: {
+      products: unique(homePageProductLinks != null ? homePageProductLinks : []),
+      collections: unique(homePageCollectionLinks != null ? homePageCollectionLinks : [])
+    },
+    jsonLdData: ((_m = (_l = html.match(
+      /<script[^>]*type="application\/ld\+json"[^>]*>([^<]+)<\/script>/g
+    )) == null ? void 0 : _l.map(
+      (match) => {
+        var _a2;
+        return ((_a2 = match == null ? void 0 : match.split(">")[1]) == null ? void 0 : _a2.replace(/<\/script/g, "")) || null;
+      }
+    )) == null ? void 0 : _m.map((json) => json ? JSON.parse(json) : null)) || [],
+    techProvider: {
+      name: "shopify",
+      walletId: shopifyWalletId,
+      subDomain: myShopifySubdomain != null ? myShopifySubdomain : null
+    },
+    country: countryDetection.country
+  };
+  const currencyCode = countryDetection == null ? void 0 : countryDetection.currencyCode;
+  return { info, currencyCode };
+}
+
+// src/store.ts
+function createStoreOperations(context) {
+  return {
+    /**
+     * Fetches comprehensive store information including metadata, social links, and showcase content.
+     *
+     * @returns {Promise<StoreInfo>} Store information object containing:
+     * - `name` - Store name from meta tags or domain
+     * - `domain` - Store domain URL
+     * - `slug` - Generated store slug
+     * - `title` - Store title from meta tags
+     * - `description` - Store description from meta tags
+     * - `logoUrl` - Store logo URL from Open Graph or CDN
+     * - `socialLinks` - Object with social media links (facebook, twitter, instagram, etc.)
+     * - `contactLinks` - Object with contact information (tel, email, contactPage)
+     * - `headerLinks` - Array of navigation links from header
+     * - `showcase` - Object with featured products and collections from homepage
+     * - `jsonLdData` - Structured data from JSON-LD scripts
+     * - `techProvider` - Shopify-specific information (walletId, subDomain)
+     * - `country` - Country detection results with ISO 3166-1 alpha-2 codes (e.g., "US", "GB")
+     *
+     * @throws {Error} When the store URL is unreachable or returns an error
+     *
+     * @example
+     * ```typescript
+     * const shop = new ShopClient('https://exampleshop.com');
+     * const storeInfo = await shop.getInfo();
+     *
+     * console.log(storeInfo.name); // "Example Store"
+     * console.log(storeInfo.socialLinks.instagram); // "https://instagram.com/example"
+     * console.log(storeInfo.showcase.products); // ["product-handle-1", "product-handle-2"]
+     * console.log(storeInfo.country); // "US"
+     * ```
+     */
+    info: async () => {
+      try {
+        const { info } = await getInfoForStore({
+          baseUrl: context.baseUrl,
+          storeDomain: context.storeDomain,
+          validateProductExists: context.validateProductExists,
+          validateCollectionExists: context.validateCollectionExists,
+          validateLinksInBatches: context.validateLinksInBatches
+        });
+        return info;
+      } catch (error) {
+        context.handleFetchError(error, "fetching store info", context.baseUrl);
+      }
+    }
+  };
+}
+
+export {
+  getInfoForStore,
+  createStoreOperations
+};