shop-client 3.9.0 → 3.9.2

package/dist/index.js

@@ -0,0 +1,753 @@
+import {
+  createCheckoutOperations
+} from "./chunk-RR6YTQWP.js";
+import {
+  createCollectionOperations
+} from "./chunk-MOBWPEY4.js";
+import {
+  createProductOperations
+} from "./chunk-CXUCPK6X.js";
+import {
+  createStoreOperations,
+  getInfoForStore
+} from "./chunk-DJQEZNHG.js";
+import {
+  classifyProduct,
+  determineStoreType,
+  generateSEOContent
+} from "./chunk-VPPCOJC3.js";
+import {
+  configureRateLimit,
+  rateLimitedFetch
+} from "./chunk-2MF53V33.js";
+import {
+  detectShopCountry
+} from "./chunk-QUDGES3A.js";
+import {
+  buildVariantOptionsMap,
+  calculateDiscount,
+  extractDomainWithoutSuffix,
+  genProductSlug,
+  generateStoreSlug,
+  normalizeKey,
+  safeParseDate,
+  sanitizeDomain
+} from "./chunk-CN7L3BHG.js";
+
+// src/ai/determine-store-type.ts
+async function determineStoreTypeForStore(args) {
+  var _a, _b, _c;
+  const info = await args.getInfo();
+  const maxProducts = Math.max(0, Math.min(50, (_a = args.maxShowcaseProducts) != null ? _a : 10));
+  const maxCollections = Math.max(
+    0,
+    Math.min(50, (_b = args.maxShowcaseCollections) != null ? _b : 10)
+  );
+  const take = (arr, n) => arr.slice(0, Math.max(0, n));
+  const productsSample = Array.isArray(info.showcase.products) ? take(info.showcase.products, maxProducts) : [];
+  const collectionsSample = Array.isArray(info.showcase.collections) ? take(info.showcase.collections, maxCollections) : [];
+  const breakdown = await determineStoreType(
+    {
+      title: info.title || info.name,
+      description: (_c = info.description) != null ? _c : null,
+      showcase: {
+        products: productsSample,
+        collections: collectionsSample
+      }
+    },
+    { apiKey: args.apiKey, model: args.model }
+  );
+  return breakdown;
+}
+
+// src/dto/collections.dto.ts
+function collectionsDto(collections) {
+  if (!collections || collections.length === 0) return null;
+  return collections.map((collection) => ({
+    id: collection.id.toString(),
+    title: collection.title,
+    handle: collection.handle,
+    description: collection.description,
+    image: collection.image ? {
+      id: collection.image.id,
+      createdAt: collection.image.created_at,
+      src: collection.image.src,
+      alt: collection.image.alt
+    } : void 0,
+    productsCount: collection.products_count,
+    publishedAt: collection.published_at,
+    updatedAt: collection.updated_at
+  }));
+}
+
+// src/dto/products.mapped.ts
+function mapVariants(product) {
+  var _a;
+  const variants = (_a = product.variants) != null ? _a : [];
+  return variants.map((variant) => {
+    var _a2;
+    return {
+      id: variant.id.toString(),
+      platformId: variant.id.toString(),
+      name: variant.name,
+      title: variant.title,
+      option1: variant.option1 || null,
+      option2: variant.option2 || null,
+      option3: variant.option3 || null,
+      options: [variant.option1, variant.option2, variant.option3].filter(
+        Boolean
+      ),
+      sku: variant.sku || null,
+      requiresShipping: variant.requires_shipping,
+      taxable: variant.taxable,
+      featuredImage: variant.featured_image ? {
+        id: variant.featured_image.id,
+        src: variant.featured_image.src,
+        width: variant.featured_image.width,
+        height: variant.featured_image.height,
+        position: variant.featured_image.position,
+        productId: variant.featured_image.product_id,
+        aspectRatio: variant.featured_image.aspect_ratio || 0,
+        variantIds: variant.featured_image.variant_ids || [],
+        createdAt: variant.featured_image.created_at,
+        updatedAt: variant.featured_image.updated_at,
+        alt: variant.featured_image.alt
+      } : null,
+      available: Boolean(variant.available),
+      price: typeof variant.price === "string" ? Number.parseFloat(variant.price) * 100 : variant.price,
+      weightInGrams: (_a2 = variant.weightInGrams) != null ? _a2 : variant.grams,
+      compareAtPrice: variant.compare_at_price ? typeof variant.compare_at_price === "string" ? Number.parseFloat(variant.compare_at_price) * 100 : variant.compare_at_price : 0,
+      position: variant.position,
+      productId: variant.product_id,
+      createdAt: variant.created_at,
+      updatedAt: variant.updated_at
+    };
+  });
+}
+function mapProductsDto(products, ctx) {
+  if (!products || products.length === 0) return null;
+  return products.map((product) => {
+    var _a, _b, _c;
+    const optionNames = product.options.map((o) => o.name);
+    const variantOptionsMap = buildVariantOptionsMap(
+      optionNames,
+      product.variants
+    );
+    const mappedVariants = mapVariants(product);
+    const priceValues = mappedVariants.map((v) => v.price).filter((p) => typeof p === "number" && !Number.isNaN(p));
+    const compareAtValues = mappedVariants.map((v) => v.compareAtPrice || 0).filter((p) => typeof p === "number" && !Number.isNaN(p));
+    const priceMin = priceValues.length ? Math.min(...priceValues) : 0;
+    const priceMax = priceValues.length ? Math.max(...priceValues) : 0;
+    const priceVaries = mappedVariants.length > 1 && priceMin !== priceMax;
+    const compareAtMin = compareAtValues.length ? Math.min(...compareAtValues) : 0;
+    const compareAtMax = compareAtValues.length ? Math.max(...compareAtValues) : 0;
+    const compareAtVaries = mappedVariants.length > 1 && compareAtMin !== compareAtMax;
+    return {
+      slug: genProductSlug({
+        handle: product.handle,
+        storeDomain: ctx.storeDomain
+      }),
+      handle: product.handle,
+      platformId: product.id.toString(),
+      title: product.title,
+      available: mappedVariants.some((v) => v.available),
+      price: priceMin,
+      priceMin,
+      priceMax,
+      priceVaries,
+      compareAtPrice: compareAtMin,
+      compareAtPriceMin: compareAtMin,
+      compareAtPriceMax: compareAtMax,
+      compareAtPriceVaries: compareAtVaries,
+      discount: 0,
+      currency: ctx.currency,
+      localizedPricing: {
+        currency: ctx.currency,
+        priceFormatted: ctx.formatPrice(priceMin),
+        priceMinFormatted: ctx.formatPrice(priceMin),
+        priceMaxFormatted: ctx.formatPrice(priceMax),
+        compareAtPriceFormatted: ctx.formatPrice(compareAtMin)
+      },
+      options: product.options.map((option) => ({
+        key: normalizeKey(option.name),
+        data: option.values,
+        name: option.name,
+        position: option.position,
+        values: option.values
+      })),
+      variantOptionsMap,
+      bodyHtml: product.body_html || null,
+      active: true,
+      productType: product.product_type || null,
+      tags: Array.isArray(product.tags) ? product.tags : [],
+      vendor: product.vendor,
+      featuredImage: ((_b = (_a = product.images) == null ? void 0 : _a[0]) == null ? void 0 : _b.src) ? ctx.normalizeImageUrl(product.images[0].src) : null,
+      isProxyFeaturedImage: false,
+      createdAt: safeParseDate(product.created_at),
+      updatedAt: safeParseDate(product.updated_at),
+      variants: mappedVariants,
+      images: product.images.map((image) => ({
+        id: image.id,
+        productId: image.product_id,
+        alt: null,
+        position: image.position,
+        src: ctx.normalizeImageUrl(image.src),
+        width: image.width,
+        height: image.height,
+        mediaType: "image",
+        variantIds: image.variant_ids || [],
+        createdAt: image.created_at,
+        updatedAt: image.updated_at
+      })),
+      publishedAt: (_c = safeParseDate(product.published_at)) != null ? _c : null,
+      seo: null,
+      metaTags: null,
+      displayScore: void 0,
+      deletedAt: null,
+      storeSlug: ctx.storeSlug,
+      storeDomain: ctx.storeDomain,
+      url: `${ctx.storeDomain}/products/${product.handle}`
+    };
+  });
+}
+function mapProductDto(product, ctx) {
+  var _a;
+  const optionNames = product.options.map((o) => o.name);
+  const variantOptionsMap = buildVariantOptionsMap(
+    optionNames,
+    product.variants
+  );
+  const mapped = {
+    slug: genProductSlug({
+      handle: product.handle,
+      storeDomain: ctx.storeDomain
+    }),
+    handle: product.handle,
+    platformId: product.id.toString(),
+    title: product.title,
+    available: product.available,
+    price: product.price,
+    priceMin: product.price_min,
+    priceMax: product.price_max,
+    priceVaries: product.price_varies,
+    compareAtPrice: product.compare_at_price || 0,
+    compareAtPriceMin: product.compare_at_price_min,
+    compareAtPriceMax: product.compare_at_price_max,
+    compareAtPriceVaries: product.compare_at_price_varies,
+    discount: 0,
+    currency: ctx.currency,
+    localizedPricing: {
+      currency: ctx.currency,
+      priceFormatted: ctx.formatPrice(product.price),
+      priceMinFormatted: ctx.formatPrice(product.price_min),
+      priceMaxFormatted: ctx.formatPrice(product.price_max),
+      compareAtPriceFormatted: ctx.formatPrice(product.compare_at_price || 0)
+    },
+    options: product.options.map((option) => ({
+      key: normalizeKey(option.name),
+      data: option.values,
+      name: option.name,
+      position: option.position,
+      values: option.values
+    })),
+    variantOptionsMap,
+    bodyHtml: product.description || null,
+    active: true,
+    productType: product.type || null,
+    tags: Array.isArray(product.tags) ? product.tags : typeof product.tags === "string" ? [product.tags] : [],
+    vendor: product.vendor,
+    featuredImage: ctx.normalizeImageUrl(product.featured_image),
+    isProxyFeaturedImage: false,
+    createdAt: safeParseDate(product.created_at),
+    updatedAt: safeParseDate(product.updated_at),
+    variants: mapVariants(product),
+    images: Array.isArray(product.images) ? product.images.map((imageSrc, index) => ({
+      id: index + 1,
+      productId: product.id,
+      alt: null,
+      position: index + 1,
+      src: ctx.normalizeImageUrl(imageSrc),
+      width: 0,
+      height: 0,
+      mediaType: "image",
+      variantIds: [],
+      createdAt: product.created_at,
+      updatedAt: product.updated_at
+    })) : [],
+    publishedAt: (_a = safeParseDate(product.published_at)) != null ? _a : null,
+    seo: null,
+    metaTags: null,
+    displayScore: void 0,
+    deletedAt: null,
+    storeSlug: ctx.storeSlug,
+    storeDomain: ctx.storeDomain,
+    url: product.url || `${ctx.storeDomain}/products/${product.handle}`
+  };
+  return mapped;
+}
+
+// src/index.ts
+var ShopClient = class {
+  /**
+   * Creates a new ShopClient instance for interacting with a Shopify store.
+   *
+   * @param urlPath - The Shopify store URL (e.g., 'https://exampleshop.com' or 'exampleshop.com')
+   *
+   * @throws {Error} When the URL is invalid or contains malicious patterns
+   *
+   * @example
+   * ```typescript
+   * // With full URL
+   * const shop = new ShopClient('https://exampleshop.com');
+   *
+   * // Without protocol (automatically adds https://)
+   * const shop = new ShopClient('exampleshop.com');
+   *
+   * // Works with any Shopify store domain
+   * const shop1 = new ShopClient('https://example.myshopify.com');
+   * const shop2 = new ShopClient('https://boutique.fashion');
+   * ```
+   */
+  constructor(urlPath, options) {
+    this.validationCache = /* @__PURE__ */ new Map();
+    this.cacheExpiry = 5 * 60 * 1e3;
+    // 5 minutes
+    this.cacheTimestamps = /* @__PURE__ */ new Map();
+    this.normalizeImageUrlCache = /* @__PURE__ */ new Map();
+    if (!urlPath || typeof urlPath !== "string") {
+      throw new Error("Store URL is required and must be a string");
+    }
+    let normalizedUrl = urlPath.trim();
+    if (!normalizedUrl.startsWith("http://") && !normalizedUrl.startsWith("https://")) {
+      normalizedUrl = `https://${normalizedUrl}`;
+    }
+    let storeUrl;
+    try {
+      storeUrl = new URL(normalizedUrl);
+    } catch (_error) {
+      throw new Error("Invalid store URL format");
+    }
+    const hostname = storeUrl.hostname;
+    if (!hostname || hostname.length < 3) {
+      throw new Error("Invalid domain name");
+    }
+    if (hostname.includes("..") || hostname.includes("//") || hostname.includes("@")) {
+      throw new Error("Invalid characters in domain name");
+    }
+    if (!hostname.includes(".") || hostname.startsWith(".") || hostname.endsWith(".")) {
+      throw new Error(
+        "Invalid domain format - must be a valid domain with TLD"
+      );
+    }
+    const domainPattern = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    if (!domainPattern.test(hostname)) {
+      throw new Error("Invalid domain format");
+    }
+    this.storeDomain = `https://${hostname}`;
+    let fetchUrl = `https://${hostname}${storeUrl.pathname}`;
+    if (!fetchUrl.endsWith("/")) {
+      fetchUrl = `${fetchUrl}/`;
+    }
+    this.baseUrl = fetchUrl;
+    this.storeSlug = generateStoreSlug(this.storeDomain);
+    if (typeof (options == null ? void 0 : options.cacheTTL) === "number" && options.cacheTTL > 0) {
+      this.cacheExpiry = options.cacheTTL;
+    }
+    this.storeOperations = createStoreOperations({
+      baseUrl: this.baseUrl,
+      storeDomain: this.storeDomain,
+      validateProductExists: this.validateProductExists.bind(this),
+      validateCollectionExists: this.validateCollectionExists.bind(this),
+      validateLinksInBatches: this.validateLinksInBatches.bind(this),
+      handleFetchError: this.handleFetchError.bind(this)
+    });
+    this.products = createProductOperations(
+      this.baseUrl,
+      this.storeDomain,
+      this.fetchProducts.bind(this),
+      this.productsDto.bind(this),
+      this.productDto.bind(this),
+      () => this.getInfo(),
+      (handle) => this.products.find(handle)
+    );
+    this.collections = createCollectionOperations(
+      this.baseUrl,
+      this.storeDomain,
+      this.fetchCollections.bind(this),
+      this.collectionsDto.bind(this),
+      this.fetchPaginatedProductsFromCollection.bind(this),
+      () => this.getInfo(),
+      (handle) => this.collections.find(handle)
+    );
+    this.checkout = createCheckoutOperations(this.baseUrl);
+  }
+  /**
+   * Optimized image URL normalization with caching
+   */
+  normalizeImageUrl(url) {
+    if (!url) {
+      return "";
+    }
+    if (this.normalizeImageUrlCache.has(url)) {
+      return this.normalizeImageUrlCache.get(url);
+    }
+    const normalized = url.startsWith("//") ? `https:${url}` : url;
+    this.normalizeImageUrlCache.set(url, normalized);
+    return normalized;
+  }
+  /**
+   * Format a price amount (in cents) using the store currency.
+   */
+  formatPrice(amountInCents) {
+    var _a;
+    const currency = (_a = this.storeCurrency) != null ? _a : "USD";
+    try {
+      return new Intl.NumberFormat(void 0, {
+        style: "currency",
+        currency
+      }).format((amountInCents || 0) / 100);
+    } catch {
+      const val = (amountInCents || 0) / 100;
+      return `${val} ${currency}`;
+    }
+  }
+  /**
+   * Transform Shopify products to our Product format
+   */
+  productsDto(products) {
+    var _a;
+    return mapProductsDto(products, {
+      storeDomain: this.storeDomain,
+      storeSlug: this.storeSlug,
+      currency: (_a = this.storeCurrency) != null ? _a : "USD",
+      normalizeImageUrl: (url) => this.normalizeImageUrl(url),
+      formatPrice: (amount) => this.formatPrice(amount)
+    });
+  }
+  productDto(product) {
+    var _a;
+    return mapProductDto(product, {
+      storeDomain: this.storeDomain,
+      storeSlug: this.storeSlug,
+      currency: (_a = this.storeCurrency) != null ? _a : "USD",
+      normalizeImageUrl: (url) => this.normalizeImageUrl(url),
+      formatPrice: (amount) => this.formatPrice(amount)
+    });
+  }
+  collectionsDto(collections) {
+    var _a;
+    return (_a = collectionsDto(collections)) != null ? _a : [];
+  }
+  /**
+   * Enhanced error handling with context
+   */
+  handleFetchError(error, context, url) {
+    let errorMessage = `Error ${context}`;
+    let statusCode;
+    if (error instanceof Error) {
+      errorMessage += `: ${error.message}`;
+      const anyErr = error;
+      if (anyErr && typeof anyErr.status === "number") {
+        statusCode = anyErr.status;
+      }
+    } else if (typeof error === "string") {
+      errorMessage += `: ${error}`;
+    } else {
+      errorMessage += ": Unknown error occurred";
+    }
+    errorMessage += ` (URL: ${url})`;
+    if (statusCode) {
+      errorMessage += ` (Status: ${statusCode})`;
+    }
+    const enhancedError = new Error(errorMessage);
+    enhancedError.context = context;
+    enhancedError.url = url;
+    enhancedError.statusCode = statusCode;
+    enhancedError.originalError = error;
+    throw enhancedError;
+  }
+  /**
+   * Fetch products with pagination
+   */
+  async fetchProducts(page, limit) {
+    try {
+      const url = `${this.baseUrl}products.json?page=${page}&limit=${limit}`;
+      const response = await rateLimitedFetch(url, {
+        rateLimitClass: "products:list"
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.productsDto(data.products);
+    } catch (error) {
+      this.handleFetchError(
+        error,
+        "fetching products",
+        `${this.baseUrl}products.json`
+      );
+    }
+  }
+  /**
+   * Fetch collections with pagination
+   */
+  async fetchCollections(page, limit) {
+    try {
+      const url = `${this.baseUrl}collections.json?page=${page}&limit=${limit}`;
+      const response = await rateLimitedFetch(url, {
+        rateLimitClass: "collections:list"
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.collectionsDto(data.collections);
+    } catch (error) {
+      this.handleFetchError(
+        error,
+        "fetching collections",
+        `${this.baseUrl}collections.json`
+      );
+    }
+  }
+  /**
+   * Fetch paginated products from a specific collection
+   */
+  async fetchPaginatedProductsFromCollection(collectionHandle, options = {}) {
+    try {
+      const { page = 1, limit = 250 } = options;
+      let finalHandle = collectionHandle;
+      try {
+        const htmlResp = await rateLimitedFetch(
+          `${this.baseUrl}collections/${encodeURIComponent(collectionHandle)}`,
+          { rateLimitClass: "collections: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("collections");
+            const maybeHandle = idx >= 0 ? parts[idx + 1] : void 0;
+            if (typeof maybeHandle === "string" && maybeHandle.length) {
+              finalHandle = maybeHandle;
+            }
+          }
+        }
+      } catch {
+      }
+      const url = `${this.baseUrl}collections/${finalHandle}/products.json?page=${page}&limit=${limit}`;
+      const response = await rateLimitedFetch(url, {
+        rateLimitClass: "collections:items"
+      });
+      if (!response.ok) {
+        if (response.status === 404) {
+          return null;
+        }
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.productsDto(data.products);
+    } catch (error) {
+      this.handleFetchError(
+        error,
+        "fetching products from collection",
+        `${this.baseUrl}collections/${collectionHandle}/products.json`
+      );
+    }
+  }
+  /**
+   * Validate if a product exists (with caching)
+   */
+  async validateProductExists(handle) {
+    const cacheKey = `product:${handle}`;
+    if (this.isCacheValid(cacheKey)) {
+      return this.validationCache.get(cacheKey) || false;
+    }
+    try {
+      const url = `${this.baseUrl}products/${handle}.js`;
+      const response = await rateLimitedFetch(url, {
+        method: "HEAD",
+        rateLimitClass: "validate:product"
+      });
+      const exists = response.ok;
+      this.setCacheValue(cacheKey, exists);
+      return exists;
+    } catch (_error) {
+      this.setCacheValue(cacheKey, false);
+      return false;
+    }
+  }
+  /**
+   * Validate if a collection exists (with caching)
+   */
+  async validateCollectionExists(handle) {
+    const cacheKey = `collection:${handle}`;
+    if (this.isCacheValid(cacheKey)) {
+      return this.validationCache.get(cacheKey) || false;
+    }
+    try {
+      const url = `${this.baseUrl}collections/${handle}.json`;
+      const response = await rateLimitedFetch(url, {
+        method: "HEAD",
+        rateLimitClass: "validate:collection"
+      });
+      const exists = response.ok;
+      this.setCacheValue(cacheKey, exists);
+      return exists;
+    } catch (_error) {
+      this.setCacheValue(cacheKey, false);
+      return false;
+    }
+  }
+  /**
+   * Check if cache entry is still valid
+   */
+  isCacheValid(key) {
+    const timestamp = this.cacheTimestamps.get(key);
+    if (!timestamp) return false;
+    return Date.now() - timestamp < this.cacheExpiry;
+  }
+  /**
+   * Set cache value with timestamp
+   */
+  setCacheValue(key, value) {
+    this.validationCache.set(key, value);
+    this.cacheTimestamps.set(key, Date.now());
+  }
+  /**
+   * Validate links in batches to avoid overwhelming the server
+   */
+  async validateLinksInBatches(items, validator, batchSize = 10) {
+    const validItems = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      const validationPromises = batch.map(async (item) => {
+        const isValid = await validator(item);
+        return isValid ? item : null;
+      });
+      const results = await Promise.all(validationPromises);
+      const validBatchItems = results.filter(
+        (item) => item !== null
+      );
+      validItems.push(...validBatchItems);
+      if (i + batchSize < items.length) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    }
+    return validItems;
+  }
+  /**
+   * 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"
+   * ```
+   */
+  /**
+   * Optionally bypass cache and force a fresh fetch.
+   *
+   * @param options - `{ force?: boolean }` when `true`, ignores cached value and TTL.
+   */
+  async getInfo(options) {
+    try {
+      if ((options == null ? void 0 : options.force) === true) {
+        this.clearInfoCache();
+      }
+      if (this.infoCacheValue && this.infoCacheTimestamp !== void 0 && Date.now() - this.infoCacheTimestamp < this.cacheExpiry) {
+        return this.infoCacheValue;
+      }
+      if (this.infoInFlight) {
+        return await this.infoInFlight;
+      }
+      this.infoInFlight = (async () => {
+        const { info, currencyCode } = await getInfoForStore({
+          baseUrl: this.baseUrl,
+          storeDomain: this.storeDomain,
+          validateProductExists: (handle) => this.validateProductExists(handle),
+          validateCollectionExists: (handle) => this.validateCollectionExists(handle),
+          validateLinksInBatches: (items, validator, batchSize) => this.validateLinksInBatches(items, validator, batchSize)
+        });
+        if (typeof currencyCode === "string") {
+          this.storeCurrency = currencyCode;
+        }
+        this.infoCacheValue = info;
+        this.infoCacheTimestamp = Date.now();
+        return info;
+      })();
+      try {
+        const result = await this.infoInFlight;
+        return result;
+      } finally {
+        this.infoInFlight = void 0;
+      }
+    } catch (error) {
+      throw this.handleFetchError(error, "fetching store info", this.baseUrl);
+    }
+  }
+  /**
+   * Manually clear the cached store info.
+   * The next call to `getInfo()` will fetch fresh data regardless of TTL.
+   */
+  clearInfoCache() {
+    this.infoCacheValue = void 0;
+    this.infoCacheTimestamp = void 0;
+  }
+  /**
+   * Determine the store's primary vertical and target audience.
+   * Uses `getInfo()` internally; no input required.
+   */
+  async determineStoreType(options) {
+    try {
+      const breakdown = await determineStoreTypeForStore({
+        baseUrl: this.baseUrl,
+        getInfo: () => this.getInfo(),
+        findProduct: (handle) => this.products.find(handle),
+        apiKey: options == null ? void 0 : options.apiKey,
+        model: options == null ? void 0 : options.model,
+        maxShowcaseProducts: options == null ? void 0 : options.maxShowcaseProducts,
+        maxShowcaseCollections: options == null ? void 0 : options.maxShowcaseCollections
+      });
+      return breakdown;
+    } catch (error) {
+      throw this.handleFetchError(error, "determineStoreType", this.baseUrl);
+    }
+  }
+};
+export {
+  ShopClient,
+  calculateDiscount,
+  classifyProduct,
+  configureRateLimit,
+  detectShopCountry,
+  extractDomainWithoutSuffix,
+  genProductSlug,
+  generateSEOContent,
+  generateStoreSlug,
+  safeParseDate,
+  sanitizeDomain
+};