shop-client 3.16.0 → 3.18.0

package/dist/chunk-6XDBGOFZ.mjs

@@ -0,0 +1,804 @@
+import {
+  rateLimitedFetch
+} from "./chunk-O77Z6OBJ.mjs";
+import {
+  formatPrice
+} from "./chunk-U3RQRBXZ.mjs";
+
+// src/products.ts
+import { filter, isNonNullish } from "remeda";
+function createProductOperations(baseUrl, storeDomain, fetchProducts, productsDto, productDto, getStoreInfo, _findProduct, ai) {
+  const cacheExpiryMs = 5 * 60 * 1e3;
+  const findCacheFull = /* @__PURE__ */ new Map();
+  const findCacheMinimal = /* @__PURE__ */ new Map();
+  const getCachedFull = (key) => {
+    const entry = findCacheFull.get(key);
+    if (!entry) return void 0;
+    if (Date.now() - entry.ts < cacheExpiryMs) return entry.value;
+    findCacheFull.delete(key);
+    return void 0;
+  };
+  const setCachedFull = (key, value) => {
+    findCacheFull.set(key, { ts: Date.now(), value });
+  };
+  const getCachedMinimal = (key) => {
+    const entry = findCacheMinimal.get(key);
+    if (!entry) return void 0;
+    if (Date.now() - entry.ts < cacheExpiryMs) return entry.value;
+    findCacheMinimal.delete(key);
+    return void 0;
+  };
+  const setCachedMinimal = (key, value) => {
+    findCacheMinimal.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 applyCurrencyOverrideMinimal(product, currency) {
+    var _a;
+    const compareAtPrice = (_a = product.compareAtPrice) != null ? _a : 0;
+    return {
+      ...product,
+      localizedPricing: {
+        priceFormatted: formatPrice(product.price, currency),
+        compareAtPriceFormatted: formatPrice(compareAtPrice, currency)
+      }
+    };
+  }
+  function maybeOverrideProductsCurrency(products, currency) {
+    if (!products || !currency || products.length === 0) return products;
+    return products.map((p) => applyCurrencyOverride(p, currency));
+  }
+  function maybeOverrideMinimalProductsCurrency(products, currency) {
+    if (!products || !currency || products.length === 0) return products;
+    return products.map((p) => applyCurrencyOverrideMinimal(p, currency));
+  }
+  async function allInternal(options) {
+    const limit = 250;
+    const allProducts = [];
+    async function fetchAll() {
+      let currentPage = 1;
+      while (true) {
+        const products = await fetchProducts(currentPage, limit, {
+          minimal: options.minimal
+        });
+        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 options.minimal ? maybeOverrideMinimalProductsCurrency(
+        products,
+        options.currency
+      ) : maybeOverrideProductsCurrency(
+        products,
+        options.currency
+      );
+    } catch (error) {
+      console.error("Failed to fetch all products:", storeDomain, error);
+      throw error;
+    }
+  }
+  async function paginatedInternal(options) {
+    var _a, _b;
+    const page = (_a = options.page) != null ? _a : 1;
+    const limit = Math.min((_b = 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, {
+        minimal: options.minimal
+      });
+      return options.minimal ? maybeOverrideMinimalProductsCurrency(
+        normalized || null,
+        options.currency
+      ) : maybeOverrideProductsCurrency(
+        normalized || null,
+        options.currency
+      );
+    } catch (error) {
+      console.error(
+        `Error fetching products for ${storeDomain} page ${page} with limit ${limit}:`,
+        error
+      );
+      return null;
+    }
+  }
+  async function findInternal(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 = options.minimal ? getCachedMinimal(sanitizedHandle) : getCachedFull(sanitizedHandle);
+      if (typeof cached !== "undefined") {
+        if (!cached || !options.currency) return cached;
+        return options.minimal ? applyCurrencyOverrideMinimal(
+          cached,
+          options.currency
+        ) : applyCurrencyOverride(cached, options.currency);
+      }
+      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, { minimal: options.minimal });
+      if (options.minimal) {
+        const minimalData = productData;
+        setCachedMinimal(sanitizedHandle, minimalData);
+        if (finalHandle !== sanitizedHandle)
+          setCachedMinimal(finalHandle, minimalData);
+        return options.currency ? applyCurrencyOverrideMinimal(minimalData, options.currency) : minimalData;
+      }
+      const fullData = productData;
+      setCachedFull(sanitizedHandle, fullData);
+      if (finalHandle !== sanitizedHandle) setCachedFull(finalHandle, fullData);
+      return options.currency ? applyCurrencyOverride(fullData, options.currency) : fullData;
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(
+          `Error fetching product ${productHandle}:`,
+          baseUrl,
+          error.message
+        );
+      }
+      throw error;
+    }
+  }
+  async function predictiveSearchInternal(query, options) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!query || typeof query !== "string") {
+      throw new Error("Query is required and must be a string");
+    }
+    const limit = Math.max(1, Math.min((_a = options.limit) != null ? _a : 10, 10));
+    const unavailable = options.unavailableProducts === "show" || options.unavailableProducts === "hide" ? options.unavailableProducts : "hide";
+    const localeValue = options.locale && options.locale.trim() || "en";
+    const localePrefix = `${localeValue.replace(/^\/|\/$/g, "")}/`;
+    const url = `${baseUrl}${localePrefix}search/suggest.json?q=${encodeURIComponent(query)}&resources[type]=product&resources[limit]=${limit}&resources[options][unavailable_products]=${unavailable}`;
+    const response = await rateLimitedFetch(url, {
+      rateLimitClass: "search:predictive",
+      timeoutMs: 7e3,
+      retry: { maxRetries: 2, baseDelayMs: 300 }
+    });
+    let resp = response;
+    if (!resp.ok && (resp.status === 404 || resp.status === 417)) {
+      const fallbackUrl = `${baseUrl}search/suggest.json?q=${encodeURIComponent(query)}&resources[type]=product&resources[limit]=${limit}&resources[options][unavailable_products]=${unavailable}`;
+      resp = await rateLimitedFetch(fallbackUrl, {
+        rateLimitClass: "search:predictive",
+        timeoutMs: 7e3,
+        retry: { maxRetries: 2, baseDelayMs: 300 }
+      });
+    }
+    if (!resp.ok) {
+      throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+    }
+    const data = await resp.json();
+    const raw = (_d = (_c = (_b = data == null ? void 0 : data.resources) == null ? void 0 : _b.results) == null ? void 0 : _c.products) != null ? _d : [];
+    const handles = raw.filter((p) => p.available !== false).map((p) => p.handle).filter((h) => typeof h === "string" && h.length > 0).slice(0, limit);
+    const fetched = await Promise.all(
+      handles.map((h) => findInternal(h, { minimal: options.minimal }))
+    );
+    const results = filter(fetched, isNonNullish);
+    const finalProducts = options.minimal ? (_e = maybeOverrideMinimalProductsCurrency(
+      results,
+      options.currency
+    )) != null ? _e : [] : (_f = maybeOverrideProductsCurrency(
+      results,
+      options.currency
+    )) != null ? _f : [];
+    return finalProducts;
+  }
+  async function recommendationsInternal(productId, options) {
+    var _a, _b;
+    if (!Number.isFinite(productId) || productId <= 0) {
+      throw new Error("Valid productId is required");
+    }
+    const limit = Math.max(1, Math.min((_a = options.limit) != null ? _a : 10, 10));
+    const intent = (_b = options.intent) != null ? _b : "related";
+    const localeValue = options.locale && options.locale.trim() || "en";
+    const localePrefix = `${localeValue.replace(/^\/|\/$/g, "")}/`;
+    const url = `${baseUrl}${localePrefix}recommendations/products.json?product_id=${encodeURIComponent(String(productId))}&limit=${limit}&intent=${intent}`;
+    const resp = await rateLimitedFetch(url, {
+      rateLimitClass: "products:recommendations",
+      timeoutMs: 7e3,
+      retry: { maxRetries: 2, baseDelayMs: 300 }
+    });
+    if (!resp.ok) {
+      if (resp.status === 404) {
+        return [];
+      }
+      throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+    }
+    const data = await resp.json();
+    const isRecord = (v) => typeof v === "object" && v !== null;
+    const productsArray = Array.isArray(data) ? data : isRecord(data) && Array.isArray(data.products) ? data.products : [];
+    const normalized = productsDto(productsArray, { minimal: options.minimal }) || [];
+    const finalProducts = options.minimal ? maybeOverrideMinimalProductsCurrency(
+      normalized,
+      options.currency
+    ) : maybeOverrideProductsCurrency(
+      normalized,
+      options.currency
+    );
+    return finalProducts != null ? finalProducts : [];
+  }
+  async function findEnhancedInternal(productHandle, options) {
+    var _a;
+    const apiKey = options == null ? void 0 : options.apiKey;
+    if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
+      throw new Error("apiKey is required");
+    }
+    const baseProduct = await findInternal(productHandle, { minimal: false });
+    if (!baseProduct) return null;
+    let updatedAt = (_a = baseProduct.updatedAt) == null ? void 0 : _a.toISOString();
+    if (updatedAt == null ? void 0 : updatedAt.endsWith(".000Z")) {
+      updatedAt = updatedAt.replace(".000Z", "Z");
+    }
+    if (!updatedAt) {
+      const url = `${baseUrl}products/${encodeURIComponent(baseProduct.handle)}.js`;
+      const resp2 = await rateLimitedFetch(url, {
+        rateLimitClass: "products:single",
+        timeoutMs: 7e3,
+        retry: { maxRetries: 1, baseDelayMs: 200 }
+      });
+      if (!resp2.ok) {
+        if (resp2.status === 404) return null;
+        throw new Error(`HTTP ${resp2.status}: ${resp2.statusText}`);
+      }
+      const raw = await resp2.json();
+      if (typeof raw.updated_at === "string" && raw.updated_at.trim()) {
+        updatedAt = raw.updated_at;
+      } else {
+        throw new Error("updatedAt missing for product");
+      }
+    }
+    const endpoint = typeof (options == null ? void 0 : options.endpoint) === "string" && options.endpoint.trim() || "https://shopify-product-enrichment-worker.ninjacode.workers.dev";
+    let hostname = storeDomain;
+    try {
+      hostname = new URL(storeDomain).hostname;
+    } catch {
+      hostname = storeDomain.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    }
+    const resp = await rateLimitedFetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({
+        storeDomain: hostname,
+        handle: baseProduct.handle,
+        updatedAt
+      }),
+      rateLimitClass: "products:enhanced",
+      timeoutMs: 15e3,
+      retry: {
+        maxRetries: 2,
+        baseDelayMs: 300,
+        retryOnStatuses: [429, 500, 502, 503, 504]
+      }
+    });
+    if (!resp.ok) {
+      throw new Error(`HTTP ${resp.status}: ${resp.statusText}`);
+    }
+    const data = await resp.json();
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error("Invalid enhanced product response");
+    }
+    const o = data;
+    if (!("shopify" in o) || !("enrichment" in o) || !("cache" in o)) {
+      throw new Error("Invalid enhanced product response");
+    }
+    return data;
+  }
+  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) => allInternal({ currency: options == null ? void 0 : options.currency, minimal: false }),
+    /**
+     * 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) => paginatedInternal({
+      page: options == null ? void 0 : options.page,
+      limit: options == null ? void 0 : options.limit,
+      currency: options == null ? void 0 : options.currency,
+      minimal: false
+    }),
+    /**
+     * 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) => findInternal(productHandle, {
+      minimal: false,
+      currency: options == null ? void 0 : options.currency
+    }),
+    findEnhanced: async (productHandle, options) => findEnhancedInternal(productHandle, options),
+    /**
+     * 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 baseProduct = await operations.find(productHandle);
+      if (!baseProduct) return null;
+      const handle = baseProduct.handle;
+      const { enrichProduct } = await import("./ai/enrich.mjs");
+      const enriched = await enrichProduct(storeDomain, handle, {
+        apiKey: options == null ? void 0 : options.apiKey,
+        openRouter: ai == null ? void 0 : ai.openRouter,
+        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,
+        htmlContent: options == null ? void 0 : options.content
+      });
+      return {
+        ...baseProduct,
+        enriched_content: enriched.mergedMarkdown
+      };
+    },
+    enrichedPrompts: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) throw new Error("Product not found");
+      const handle = baseProduct.handle;
+      const { buildEnrichPromptForProduct } = await import("./ai/enrich.mjs");
+      return buildEnrichPromptForProduct(storeDomain, handle, {
+        useGfm: options == null ? void 0 : options.useGfm,
+        inputType: options == null ? void 0 : options.inputType,
+        outputFormat: options == null ? void 0 : options.outputFormat,
+        htmlContent: options == null ? void 0 : options.content
+      });
+    },
+    classify: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const enrichedProduct = await operations.enriched(productHandle, {
+        apiKey: options == null ? void 0 : options.apiKey,
+        inputType: "html",
+        model: options == null ? void 0 : options.model,
+        outputFormat: "json",
+        content: options == null ? void 0 : options.content
+      });
+      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.mjs");
+      const classification = await classifyProduct(productContent, {
+        apiKey: options == null ? void 0 : options.apiKey,
+        openRouter: ai == null ? void 0 : ai.openRouter,
+        model: options == null ? void 0 : options.model
+      });
+      return classification;
+    },
+    classifyPrompts: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) throw new Error("Product not found");
+      const handle = baseProduct.handle;
+      const { buildClassifyPromptForProduct } = await import("./ai/enrich.mjs");
+      return buildClassifyPromptForProduct(storeDomain, handle, {
+        useGfm: options == null ? void 0 : options.useGfm,
+        inputType: options == null ? void 0 : options.inputType,
+        htmlContent: options == null ? void 0 : options.content
+      });
+    },
+    generateSEOContent: async (productHandle, options) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      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.mjs");
+      const seo = await generateSEOContentLLM(payload, {
+        apiKey: options == null ? void 0 : options.apiKey,
+        openRouter: ai == null ? void 0 : ai.openRouter,
+        model: options == null ? void 0 : options.model
+      });
+      return seo;
+    },
+    /**
+     * Fetches the extracted HTML content from the product page.
+     * This is useful for getting the main product description and content directly from the page HTML.
+     *
+     * @param productHandle - The handle of the product
+     * @param content - Optional HTML content to extract from. If provided, skips fetching the product page.
+     * @returns {Promise<string | null>} The extracted HTML content or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Fetch from store
+     * const html = await shop.products.infoHtml("product-handle");
+     *
+     * // Use provided HTML
+     * const htmlFromContent = await shop.products.infoHtml("product-handle", "<html>...</html>");
+     * ```
+     */
+    infoHtml: async (productHandle, content) => {
+      if (!productHandle || typeof productHandle !== "string") {
+        throw new Error("Product handle is required and must be a string");
+      }
+      const { extractMainSection, fetchProductPage } = await import("./ai/enrich.mjs");
+      if (content) {
+        return extractMainSection(content);
+      }
+      const baseProduct = await operations.find(productHandle);
+      if (!baseProduct) return null;
+      const pageHtml = await fetchProductPage(storeDomain, baseProduct.handle);
+      return extractMainSection(pageHtml);
+    },
+    /**
+     * 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 normalizedHandles = storeInfo.showcase.products.map((h) => {
+        var _a;
+        return (_a = h.split("?")[0]) == null ? void 0 : _a.replace(/^\/|\/$/g, "");
+      }).filter((base) => Boolean(base));
+      const seen = /* @__PURE__ */ new Set();
+      const uniqueHandles = [];
+      for (const base of normalizedHandles) {
+        if (seen.has(base)) continue;
+        seen.add(base);
+        uniqueHandles.push(base);
+      }
+      const products = await Promise.all(
+        uniqueHandles.map(
+          (productHandle) => findInternal(productHandle, { minimal: false })
+        )
+      );
+      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, _g;
+              if ((_a = product.options) == null ? void 0 : _a.length) return;
+              if (variant.option1) {
+                const optionName = (((_c = (_b = product.options) == null ? void 0 : _b[0]) == null ? void 0 : _c.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 = (((_e = (_d = product.options) == null ? void 0 : _d[1]) == null ? void 0 : _e.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 = (((_g = (_f = product.options) == null ? void 0 : _f[2]) == null ? void 0 : _g.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;
+      }
+    },
+    predictiveSearch: async (query, options) => predictiveSearchInternal(query, {
+      limit: options == null ? void 0 : options.limit,
+      locale: options == null ? void 0 : options.locale,
+      currency: options == null ? void 0 : options.currency,
+      unavailableProducts: options == null ? void 0 : options.unavailableProducts,
+      minimal: false
+    }),
+    recommendations: async (productId, options) => recommendationsInternal(productId, {
+      limit: options == null ? void 0 : options.limit,
+      intent: options == null ? void 0 : options.intent,
+      locale: options == null ? void 0 : options.locale,
+      currency: options == null ? void 0 : options.currency,
+      minimal: false
+    }),
+    minimal: {
+      all: async (options) => {
+        return allInternal({ minimal: true, currency: options == null ? void 0 : options.currency });
+      },
+      paginated: async (options) => {
+        return paginatedInternal({
+          page: options == null ? void 0 : options.page,
+          limit: options == null ? void 0 : options.limit,
+          currency: options == null ? void 0 : options.currency,
+          minimal: true
+        });
+      },
+      find: async (productHandle, options) => {
+        return findInternal(productHandle, {
+          minimal: true,
+          currency: options == null ? void 0 : options.currency
+        });
+      },
+      showcased: async () => {
+        const res = await operations.showcase.minimal();
+        return res || [];
+      },
+      predictiveSearch: async (query, options) => {
+        return predictiveSearchInternal(query, {
+          limit: options == null ? void 0 : options.limit,
+          locale: options == null ? void 0 : options.locale,
+          currency: options == null ? void 0 : options.currency,
+          unavailableProducts: options == null ? void 0 : options.unavailableProducts,
+          minimal: true
+        });
+      },
+      recommendations: async (productId, options) => {
+        return recommendationsInternal(productId, {
+          limit: options == null ? void 0 : options.limit,
+          intent: options == null ? void 0 : options.intent,
+          locale: options == null ? void 0 : options.locale,
+          currency: options == null ? void 0 : options.currency,
+          minimal: true
+        });
+      }
+    },
+    showcase: {
+      minimal: async () => {
+        const storeInfo = await getStoreInfo();
+        const normalizedHandles = storeInfo.showcase.products.map((h) => {
+          var _a;
+          return (_a = h.split("?")[0]) == null ? void 0 : _a.replace(/^\/|\/$/g, "");
+        }).filter((base) => Boolean(base));
+        const seen = /* @__PURE__ */ new Set();
+        const uniqueHandles = [];
+        for (const base of normalizedHandles) {
+          if (seen.has(base)) continue;
+          seen.add(base);
+          uniqueHandles.push(base);
+        }
+        const products = await Promise.all(
+          uniqueHandles.map(
+            (productHandle) => findInternal(productHandle, { minimal: true })
+          )
+        );
+        return filter(products, isNonNullish);
+      }
+    }
+  };
+  return operations;
+}
+
+export {
+  createProductOperations
+};