shop-client 3.8.2

package/dist/store.js

@@ -0,0 +1,698 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/store.ts
+var store_exports = {};
+__export(store_exports, {
+  createStoreOperations: () => createStoreOperations
+});
+module.exports = __toCommonJS(store_exports);
+
+// src/client/get-info.ts
+var import_remeda = require("remeda");
+
+// 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_SYMBOLS = {
+  Rs: "IN",
+  // India
+  "\u20B9": "IN",
+  // India
+  $: "US",
+  // United States (primary, though many countries use $)
+  CA$: "CA",
+  // Canada
+  A$: "AU",
+  // Australia
+  "\xA3": "GB",
+  // United Kingdom
+  "\u20AC": "EU",
+  // European Union (not a country code, but commonly used)
+  AED: "AE",
+  // United Arab Emirates
+  "\u20A9": "KR",
+  // South Korea
+  "\xA5": "JP"
+  // Japan (primary, though China also uses ¥)
+};
+var CURRENCY_SYMBOL_TO_CODE = {
+  Rs: "INR",
+  "\u20B9": "INR",
+  $: "USD",
+  CA$: "CAD",
+  A$: "AUD",
+  "\xA3": "GBP",
+  "\u20AC": "EUR",
+  AED: "AED",
+  "\u20A9": "KRW",
+  "\xA5": "JPY"
+};
+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 detectShopifyCountry(html) {
+  var _a, _b;
+  const countryScores = {};
+  let detectedCurrencyCode;
+  const shopifyFeaturesMatch = html.match(
+    /<script[^>]+id=["']shopify-features["'][^>]*>([\s\S]*?)<\/script>/
+  );
+  if (shopifyFeaturesMatch) {
+    try {
+      const json = shopifyFeaturesMatch[1];
+      if (!json) {
+      } else {
+        const data = JSON.parse(json);
+        if (data.country)
+          scoreCountry(
+            countryScores,
+            data.country,
+            1,
+            "shopify-features.country"
+          );
+        if ((_a = data.locale) == null ? void 0 : _a.includes("-")) {
+          const [, localeCountry] = data.locale.split("-");
+          if (localeCountry) {
+            scoreCountry(
+              countryScores,
+              localeCountry.toUpperCase(),
+              0.7,
+              "shopify-features.locale"
+            );
+          }
+        }
+        if (data.moneyFormat) {
+          for (const symbol in CURRENCY_SYMBOLS) {
+            if (data.moneyFormat.includes(symbol)) {
+              const iso = CURRENCY_SYMBOLS[symbol];
+              if (typeof iso === "string") {
+                scoreCountry(countryScores, iso, 0.6, "moneyFormat symbol");
+              }
+              const code = CURRENCY_SYMBOL_TO_CODE[symbol];
+              if (!detectedCurrencyCode && typeof code === "string") {
+                detectedCurrencyCode = code;
+              }
+            }
+          }
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  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 = (_b = phone.match(/^\+\d{1,3}/)) == null ? void 0 : _b[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
+  };
+}
+
+// src/utils/func.ts
+var import_tldts = require("tldts");
+function extractDomainWithoutSuffix(domain) {
+  const parsedDomain = (0, import_tldts.parse)(domain);
+  return parsedDomain.domainWithoutSuffix;
+}
+function generateStoreSlug(domain) {
+  var _a;
+  const input = new URL(domain);
+  const parsedDomain = (0, import_tldts.parse)(input.href);
+  const domainName = (_a = parsedDomain.domainWithoutSuffix) != null ? _a : input.hostname.split(".")[0];
+  return (domainName || "").toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function sanitizeDomain(input, opts) {
+  var _a;
+  if (typeof input !== "string") {
+    throw new Error("sanitizeDomain: input must be a string");
+  }
+  let raw = input.trim();
+  if (!raw) {
+    throw new Error("sanitizeDomain: input cannot be empty");
+  }
+  const hasProtocol = /^[a-z]+:\/\//i.test(raw);
+  if (!hasProtocol && !raw.startsWith("//")) {
+    raw = `https://${raw}`;
+  }
+  const stripWWW = (_a = opts == null ? void 0 : opts.stripWWW) != null ? _a : true;
+  try {
+    let url;
+    if (raw.startsWith("//")) {
+      url = new URL(`https:${raw}`);
+    } else if (raw.includes("://")) {
+      url = new URL(raw);
+    } else {
+      url = new URL(`https://${raw}`);
+    }
+    let hostname = url.hostname.toLowerCase();
+    const hadWWW = /^www\./i.test(url.hostname);
+    if (stripWWW) hostname = hostname.replace(/^www\./, "");
+    if (!hostname.includes(".")) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    const parsed = (0, import_tldts.parse)(hostname);
+    if (!parsed.publicSuffix || parsed.isIcann === false) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    if (!stripWWW && hadWWW) {
+      return `www.${parsed.domain || hostname}`;
+    }
+    return parsed.domain || hostname;
+  } catch {
+    let hostname = raw.toLowerCase();
+    hostname = hostname.replace(/^[a-z]+:\/\//, "");
+    hostname = hostname.replace(/^\/\//, "");
+    hostname = hostname.replace(/[/:#?].*$/, "");
+    const hadWWW = /^www\./i.test(hostname);
+    if (stripWWW) hostname = hostname.replace(/^www\./, "");
+    if (!hostname.includes(".")) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    const parsed = (0, import_tldts.parse)(hostname);
+    if (!parsed.publicSuffix || parsed.isIcann === false) {
+      throw new Error("sanitizeDomain: invalid domain (missing suffix)");
+    }
+    if (!stripWWW && hadWWW) {
+      return `www.${parsed.domain || hostname}`;
+    }
+    return parsed.domain || hostname;
+  }
+}
+
+// src/utils/rate-limit.ts
+var RateLimiter = class {
+  constructor(options) {
+    this.queue = [];
+    this.inFlight = 0;
+    this.refillTimer = null;
+    this.options = options;
+    this.tokens = options.maxRequestsPerInterval;
+  }
+  startRefill() {
+    if (this.refillTimer) return;
+    this.refillTimer = setInterval(() => {
+      this.tokens = this.options.maxRequestsPerInterval;
+      this.tryRun();
+    }, this.options.intervalMs);
+    if (this.refillTimer && typeof this.refillTimer.unref === "function") {
+      this.refillTimer.unref();
+    }
+  }
+  stopRefill() {
+    if (this.refillTimer) {
+      clearInterval(this.refillTimer);
+      this.refillTimer = null;
+    }
+  }
+  ensureRefillStarted() {
+    if (!this.refillTimer) {
+      this.startRefill();
+    }
+  }
+  configure(next) {
+    this.options = { ...this.options, ...next };
+    this.options.maxRequestsPerInterval = Math.max(
+      1,
+      this.options.maxRequestsPerInterval
+    );
+    this.options.intervalMs = Math.max(10, this.options.intervalMs);
+    this.options.maxConcurrency = Math.max(1, this.options.maxConcurrency);
+  }
+  schedule(fn) {
+    return new Promise((resolve, reject) => {
+      this.ensureRefillStarted();
+      this.queue.push({ fn, resolve, reject });
+      this.tryRun();
+    });
+  }
+  tryRun() {
+    while (this.queue.length > 0 && this.inFlight < this.options.maxConcurrency && this.tokens > 0) {
+      const task = this.queue.shift();
+      this.tokens -= 1;
+      this.inFlight += 1;
+      Promise.resolve().then(task.fn).then((result) => task.resolve(result)).catch((err) => task.reject(err)).finally(() => {
+        this.inFlight -= 1;
+        setTimeout(() => this.tryRun(), 0);
+      });
+    }
+  }
+};
+var enabled = false;
+var defaultOptions = {
+  maxRequestsPerInterval: 5,
+  // 5 requests
+  intervalMs: 1e3,
+  // per second
+  maxConcurrency: 5
+  // up to 5 in parallel
+};
+var limiter = new RateLimiter(defaultOptions);
+var hostLimiters = /* @__PURE__ */ new Map();
+var classLimiters = /* @__PURE__ */ new Map();
+function getHost(input) {
+  try {
+    if (typeof input === "string") {
+      return new URL(input).host;
+    }
+    if (input instanceof URL) {
+      return input.host;
+    }
+    const url = input.url;
+    if (url) {
+      return new URL(url).host;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getHostLimiter(host) {
+  if (!host) return void 0;
+  const exact = hostLimiters.get(host);
+  if (exact) return exact;
+  for (const [key, lim] of hostLimiters.entries()) {
+    if (key.startsWith("*.") && host.endsWith(key.slice(2))) {
+      return lim;
+    }
+  }
+  return void 0;
+}
+async function rateLimitedFetch(input, init) {
+  var _a;
+  if (!enabled) {
+    return fetch(input, init);
+  }
+  const klass = init == null ? void 0 : init.rateLimitClass;
+  const byClass = klass ? classLimiters.get(klass) : void 0;
+  const byHost = getHostLimiter(getHost(input));
+  const eff = (_a = byClass != null ? byClass : byHost) != null ? _a : limiter;
+  return eff.schedule(() => fetch(input, init));
+}
+
+// src/client/get-info.ts
+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);
+  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 detectShopifyCountry(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: (0, import_remeda.unique)(homePageProductLinks != null ? homePageProductLinks : []),
+      collections: (0, import_remeda.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);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStoreOperations
+});
+//# sourceMappingURL=store.js.map