shop-client 3.8.2 → 3.9.1

package/dist/index.mjs

@@ -1,702 +0,0 @@
-import {
-  createCheckoutOperations
-} from "./chunk-QL5OUZGP.mjs";
-import {
-  createCollectionOperations
-} from "./chunk-QCTICSBE.mjs";
-import {
-  classifyProduct,
-  createProductOperations,
-  determineStoreType,
-  generateSEOContent
-} from "./chunk-WTK5HUFI.mjs";
-import {
-  createStoreOperations,
-  detectShopifyCountry,
-  getInfoForStore
-} from "./chunk-O4BPIIQ6.mjs";
-import {
-  buildVariantOptionsMap,
-  calculateDiscount,
-  extractDomainWithoutSuffix,
-  genProductSlug,
-  generateStoreSlug,
-  normalizeKey,
-  safeParseDate,
-  sanitizeDomain
-} from "./chunk-BWKBRM2Z.mjs";
-import {
-  configureRateLimit,
-  rateLimitedFetch
-} from "./chunk-2KBOKOAD.mjs";
-
-// 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) {
-    this.validationCache = /* @__PURE__ */ new Map();
-    // Simple cache for validation results
-    this.cacheExpiry = 5 * 60 * 1e3;
-    // 5 minutes cache expiry
-    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);
-    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}`;
-      if ("status" in error) {
-        statusCode = error.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);
-      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);
-      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)}`
-        );
-        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);
-      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" });
-      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" });
-      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"
-   * ```
-   */
-  async getInfo() {
-    try {
-      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;
-      }
-      return info;
-    } catch (error) {
-      this.handleFetchError(error, "fetching store info", this.baseUrl);
-    }
-  }
-  /**
-   * 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,
-  detectShopifyCountry,
-  extractDomainWithoutSuffix,
-  genProductSlug,
-  generateSEOContent,
-  generateStoreSlug,
-  safeParseDate,
-  sanitizeDomain
-};
-//# sourceMappingURL=index.mjs.map