@commerce-blocks/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2075 @@
+import { signal as j } from "@preact/signals-core";
+import { batch as lr, computed as ur, effect as dr, signal as fr } from "@preact/signals-core";
+const We = "2026-01", Ke = "https://app.uselayers.com/api/storefront/v1", ze = 1e3, ke = 1e3, $e = 100, Xe = 300 * ze, Je = "6.0.0", le = 250, z = 20, X = 250, ue = 250, de = 250, fe = 1, ge = 1;
+function N(e) {
+  return { data: e };
+}
+function m(e) {
+  return { error: e };
+}
+const Ye = /^gid:\/\/shopify\/(\w+)\/(\d+)$/;
+function Ze(e, t) {
+  return `gid://shopify/${e}/${t}`;
+}
+function et(e) {
+  return Ze("Product", e);
+}
+function tt(e) {
+  const t = e.match(Ye);
+  if (!t) return null;
+  const [, r, s] = t;
+  return nt(r) ? { type: r, numericId: parseInt(s, 10) } : null;
+}
+function rt(e) {
+  return tt(e)?.numericId ?? null;
+}
+function nt(e) {
+  return e === "Product" || e === "ProductVariant" || e === "Collection";
+}
+function xe({
+  type: e,
+  selectedOptions: t
+}) {
+  const r = t.map(({ name: s, value: i }) => `${s}:${i}`).join("-");
+  return `${e}-${r}`;
+}
+function Ue(e) {
+  return e.product_id ?? e.id;
+}
+function ye(e) {
+  return et(Ue(e));
+}
+function ae() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+const st = ["TIMEOUT", "CONNECTION_FAILED", "DNS_FAILED"];
+function oe(e) {
+  const t = st.includes(e.code);
+  return {
+    _tag: "NetworkError",
+    code: e.code,
+    message: e.message,
+    timestamp: ae(),
+    request: e.request,
+    cause: e.cause,
+    retryable: t,
+    retryAfterMs: t ? 1e3 : void 0
+  };
+}
+function ot(e) {
+  if (!e) return;
+  const t = e["retry-after"] ?? e["Retry-After"];
+  if (!t) return;
+  const r = parseInt(t, 10);
+  if (!isNaN(r)) return r * 1e3;
+  const s = new Date(t);
+  if (!isNaN(s.getTime()))
+    return Math.max(0, s.getTime() - Date.now());
+}
+function L(e) {
+  const t = e.code === "RATE_LIMITED" || e.code === "SERVICE_UNAVAILABLE" || e.status !== void 0 && e.status >= 500, r = e.retryAfterMs ?? ot(e.response?.headers) ?? (t ? 1e3 : void 0);
+  return {
+    _tag: "ApiError",
+    code: e.code,
+    source: e.source,
+    message: e.message,
+    timestamp: ae(),
+    status: e.status,
+    retryable: t,
+    retryAfterMs: r,
+    request: e.request,
+    response: e.response,
+    cause: e.cause,
+    details: e.details
+  };
+}
+function C(e) {
+  return {
+    _tag: "ValidationError",
+    code: "VALIDATION_FAILED",
+    message: e.fields.length === 1 ? `Validation failed: ${e.fields[0].message}` : `Validation failed with ${e.fields.length} errors`,
+    timestamp: ae(),
+    operation: e.operation,
+    fields: e.fields,
+    input: e.input
+  };
+}
+function D(e, t, r, s) {
+  return {
+    path: e.split("."),
+    field: e.split(".").pop() ?? e,
+    code: t,
+    message: r,
+    ...s
+  };
+}
+function B(e) {
+  return {
+    _tag: "ConfigError",
+    code: e.code,
+    message: e.message,
+    timestamp: ae(),
+    field: e.field,
+    value: e.value,
+    expected: e.expected
+  };
+}
+function jt(e) {
+  return typeof e == "object" && e !== null && typeof e._tag == "string";
+}
+function Bt(e) {
+  return "retryable" in e ? e.retryable : !1;
+}
+function at(e, t) {
+  const r = e === 401 ? "UNAUTHORIZED" : e === 403 ? "FORBIDDEN" : e === 429 ? "RATE_LIMITED" : e >= 500 ? "SERVICE_UNAVAILABLE" : "UNKNOWN";
+  return L({
+    code: r,
+    source: "layers",
+    message: t || `HTTP ${e}`,
+    status: e
+  });
+}
+function Ee(e) {
+  if (e instanceof Error && (e.name === "AbortError" || e.name === "TimeoutError")) {
+    const t = e.name === "TimeoutError" || e.message.includes("timeout");
+    return oe({
+      code: t ? "TIMEOUT" : "ABORTED",
+      message: t ? "Request timed out" : "Request was aborted",
+      cause: e
+    });
+  }
+  return oe({
+    code: "CONNECTION_FAILED",
+    message: e instanceof Error ? e.message : "Network request failed",
+    cause: e
+  });
+}
+async function _e(e) {
+  if (!e.ok) {
+    const t = await e.text().catch(() => "");
+    return m(at(e.status, t));
+  }
+  try {
+    return N(await e.json());
+  } catch (t) {
+    return m(
+      L({
+        code: "PARSE_ERROR",
+        source: "layers",
+        message: "Invalid JSON response",
+        cause: t
+      })
+    );
+  }
+}
+function be({
+  token: e,
+  json: t = !0
+}) {
+  const r = {
+    Accept: "application/json",
+    "X-Storefront-Access-Token": e,
+    "X-SDK-Client": `commerce-blocks-sdk/${Je}`
+  };
+  return t && (r["Content-Type"] = "application/json"), r;
+}
+function ve({ config: e, endpoint: t }) {
+  const { layersBaseUrl: r = Ke } = e;
+  return `${r}${t}`;
+}
+async function K(e) {
+  const t = e.config.fetch ?? fetch;
+  try {
+    const r = await t(ve({ config: e.config, endpoint: e.endpoint }), {
+      method: "POST",
+      headers: be({ token: e.config.layersPublicToken }),
+      body: JSON.stringify(e.body),
+      signal: e.signal
+    });
+    return _e(r);
+  } catch (r) {
+    return m(Ee(r));
+  }
+}
+async function it(e) {
+  const t = new URLSearchParams();
+  for (const [n, c] of Object.entries(e.params))
+    c != null && t.append(n, typeof c == "object" ? JSON.stringify(c) : String(c));
+  const r = t.toString(), s = r ? `${e.endpoint}?${r}` : e.endpoint, i = e.config.fetch ?? fetch;
+  try {
+    const n = await i(ve({ config: e.config, endpoint: s }), {
+      method: "GET",
+      headers: be({ token: e.config.layersPublicToken }),
+      signal: e.signal
+    });
+    return _e(n);
+  } catch (n) {
+    return m(Ee(n));
+  }
+}
+async function ct(e) {
+  const t = e.config.fetch ?? fetch;
+  try {
+    const r = await t(ve({ config: e.config, endpoint: e.endpoint }), {
+      method: "POST",
+      headers: be({ token: e.config.layersPublicToken, json: !1 }),
+      body: e.formData,
+      signal: e.signal
+    });
+    return _e(r);
+  } catch (r) {
+    return m(Ee(r));
+  }
+}
+function J(e, t) {
+  if (!e) return null;
+  const r = [];
+  return e.page !== void 0 && e.page < 1 && r.push(
+    D("pagination.page", "OUT_OF_RANGE", "page must be >= 1", {
+      value: e.page,
+      constraints: { min: 1 }
+    })
+  ), e.limit !== void 0 && (e.limit < 1 || e.limit > 100) && r.push(
+    D("pagination.limit", "OUT_OF_RANGE", "limit must be between 1 and 100", {
+      value: e.limit,
+      constraints: { min: 1, max: 100 }
+    })
+  ), r.length > 0 ? C({ operation: t, fields: r }) : null;
+}
+function lt(e) {
+  if (!e.layersPublicToken)
+    return m(
+      B({
+        code: "MISSING_CONFIG",
+        message: "layersPublicToken is required",
+        field: "layersPublicToken",
+        expected: "non-empty string"
+      })
+    );
+  if (!e.sorts || e.sorts.length === 0)
+    return m(
+      B({
+        code: "MISSING_CONFIG",
+        message: "At least one sort option is required",
+        field: "sorts",
+        expected: "non-empty array of Sort"
+      })
+    );
+  const t = [
+    "title",
+    "handle",
+    "body_html",
+    "vendor",
+    "product_type",
+    "available",
+    "is_gift_card",
+    "tags",
+    "images",
+    "price_range",
+    "options",
+    "options_v2",
+    "first_or_matched_variant",
+    "featured_media",
+    "variants",
+    "metafields",
+    "calculated",
+    "named_tags",
+    "category"
+  ];
+  function r(n) {
+    return [.../* @__PURE__ */ new Set([...t, ...e.attributes ?? [], ...n ?? []])];
+  }
+  const s = {
+    layersPublicToken: e.layersPublicToken,
+    layersBaseUrl: e.layersBaseUrl,
+    fetch: e.fetch
+  };
+  return N({
+    browse: async (n, c) => {
+      if (!n.collectionHandle)
+        return m(
+          C({
+            operation: "browse",
+            fields: [
+              D("collectionHandle", "REQUIRED_FIELD", "collectionHandle is required")
+            ]
+          })
+        );
+      if (!n.sort_order_code)
+        return m(
+          C({
+            operation: "browse",
+            fields: [
+              D("sort_order_code", "REQUIRED_FIELD", "sort_order_code is required")
+            ]
+          })
+        );
+      const u = J(n.pagination, "browse");
+      if (u) return m(u);
+      const { collectionHandle: d, attributes: y, ...I } = n;
+      return K({
+        config: s,
+        endpoint: `/browse/${d}`,
+        body: {
+          facets: e.facets,
+          attributes: r(y),
+          retrieveFacetCount: !0,
+          includeFacetRanges: !0,
+          ...I
+        },
+        signal: c
+      });
+    },
+    predictiveSearch: async (n, c) => n ? it({
+      config: s,
+      endpoint: "/search/complete",
+      params: { query: n },
+      signal: c
+    }) : m(
+      C({
+        operation: "predictiveSearch",
+        fields: [D("query", "REQUIRED_FIELD", "query is required")]
+      })
+    ),
+    prepareSearch: async (n, c) => {
+      if (!n.query)
+        return m(
+          C({
+            operation: "prepareSearch",
+            fields: [D("query", "REQUIRED_FIELD", "query is required")]
+          })
+        );
+      const { query: u, ...d } = n;
+      return K({
+        config: s,
+        endpoint: `/search/${encodeURIComponent(u)}/prepare`,
+        body: d,
+        signal: c
+      });
+    },
+    search: async (n, c) => {
+      if (!n.query)
+        return m(
+          C({
+            operation: "search",
+            fields: [D("query", "REQUIRED_FIELD", "query is required")]
+          })
+        );
+      const u = J(n.pagination, "search");
+      if (u) return m(u);
+      const { query: d, attributes: y, ...I } = n;
+      return K({
+        config: s,
+        endpoint: `/search/${encodeURIComponent(d)}/execute`,
+        body: {
+          facets: e.facets,
+          attributes: r(y),
+          retrieveFacetCount: !0,
+          includeFacetRanges: !0,
+          ...I
+        },
+        signal: c
+      });
+    },
+    imageSearch: async (n, c) => {
+      if (!n.image_data && !n.image_id)
+        return m(
+          C({
+            operation: "imageSearch",
+            fields: [
+              D("image_data", "REQUIRED_FIELD", "image_data or image_id is required")
+            ]
+          })
+        );
+      const u = J(n.pagination, "imageSearch");
+      if (u) return m(u);
+      const { attributes: d, ...y } = n;
+      return K({
+        config: s,
+        endpoint: "/search/image",
+        body: { attributes: r(d), ...y },
+        signal: c
+      });
+    },
+    uploadImage: async (n, c) => {
+      const u = new FormData();
+      return u.append("image", n), ct({
+        config: s,
+        endpoint: "/images/upload",
+        formData: u,
+        signal: c
+      });
+    },
+    blocks: async (n, c) => {
+      if (!n.blockId)
+        return m(
+          C({
+            operation: "block",
+            fields: [D("blockId", "REQUIRED_FIELD", "blockId is required")]
+          })
+        );
+      const u = J(n.pagination, "block");
+      if (u) return m(u);
+      const { blockId: d, attributes: y, ...I } = n;
+      return K({
+        config: s,
+        endpoint: `/blocks/${d}/products`,
+        body: {
+          facets: e.facets,
+          attributes: r(y),
+          retrieveFacetCount: !0,
+          includeFacetRanges: !0,
+          ...I
+        },
+        signal: c
+      });
+    },
+    similarProducts: async (n, c) => {
+      if (!n.productId)
+        return m(
+          C({
+            operation: "similarProducts",
+            fields: [D("productId", "REQUIRED_FIELD", "productId is required")]
+          })
+        );
+      const u = J(n.pagination, "similarProducts");
+      if (u) return m(u);
+      const { productId: d, attributes: y, ...I } = n;
+      return K({
+        config: s,
+        endpoint: `/search/product/${d}`,
+        body: { attributes: r(y), ...I },
+        signal: c
+      });
+    }
+  });
+}
+const ie = `
+  fragment SeoFields on SEO {
+    title
+    description
+  }
+`, Le = `
+  fragment FilterValueFields on FilterValue {
+    id
+    label
+    count
+    input
+  }
+`, Ve = `
+  fragment FilterFields on Filter {
+    id
+    label
+    type
+    values { ...FilterValueFields }
+  }
+`, ce = `
+  fragment ImageFields on Image {
+    url
+    altText
+    width
+    height
+  }
+`, Me = `
+  fragment MoneyFields on MoneyV2 {
+    amount
+    currencyCode
+  }
+`, Fe = `
+  fragment SelectedOptionFields on SelectedOption {
+    name
+    value
+  }
+`, Pe = `
+  fragment PriceRangeFields on ProductPriceRange {
+    minVariantPrice { ...MoneyFields }
+    maxVariantPrice { ...MoneyFields }
+  }
+`, Se = `
+  fragment ProductOptionFields on ProductOption {
+    id
+    name
+    optionValues {
+      id
+      name
+      swatch {
+        color
+        image {
+          previewImage { url }
+        }
+      }
+    }
+  }
+`, ee = `
+  fragment MetafieldFields on Metafield {
+    namespace
+    key
+    value
+    type
+  }
+`;
+function Re(e) {
+  return `
+    fragment VariantFields on ProductVariant {
+      id
+      title
+      availableForSale
+      currentlyNotInStock
+      quantityAvailable
+      sku
+      barcode
+      weight
+      weightUnit
+      requiresShipping
+      price { ...MoneyFields }
+      compareAtPrice { ...MoneyFields }
+      selectedOptions { ...SelectedOptionFields }
+      image { ...ImageFields }
+      ${e ? "metafields(identifiers: $variantMetafields) { ...MetafieldFields }" : ""}
+    }
+  `;
+}
+function we(e) {
+  const { maxImages: t, maxVariants: r, includeProductMetafields: s } = e;
+  return `
+    fragment ProductFields on Product {
+      id
+      title
+      handle
+      description
+      descriptionHtml
+      vendor
+      productType
+      tags
+      availableForSale
+      isGiftCard
+      totalInventory
+      onlineStoreUrl
+      featuredImage { ...ImageFields }
+      images(first: ${t}) { nodes { ...ImageFields } }
+      priceRange { ...PriceRangeFields }
+      compareAtPriceRange { ...PriceRangeFields }
+      options { ...ProductOptionFields }
+      variants(first: ${r}) { nodes { ...VariantFields } }
+      selectedOrFirstAvailableVariant { ...VariantFields }
+      ${s ? "metafields(identifiers: $productMetafields) { ...MetafieldFields }" : ""}
+    }
+  `;
+}
+function Ge(e) {
+  return `
+    fragment CollectionFields on Collection {
+      id
+      handle
+      title
+      description
+      descriptionHtml
+      image { ...ImageFields }
+      seo { ...SeoFields }
+      updatedAt
+      ${e ? "metafields(identifiers: $collectionMetafields) { ...MetafieldFields }" : ""}
+    }
+  `;
+}
+function He(e) {
+  return `
+    fragment PageFields on Page {
+      id
+      handle
+      title
+      body
+      bodySummary
+      seo { ...SeoFields }
+      createdAt
+      updatedAt
+      onlineStoreUrl
+      ${e ? "metafields(identifiers: $pageMetafields) { ...MetafieldFields }" : ""}
+    }
+  `;
+}
+function ut(e) {
+  const { includeProductMetafields: t, includeVariantMetafields: r } = e;
+  return [
+    ce,
+    Me,
+    Fe,
+    Pe,
+    Se,
+    t || r ? ee : "",
+    Re(r),
+    we(e)
+  ].join(`
+`);
+}
+function dt(e = {}) {
+  const {
+    maxImages: t = z,
+    maxVariants: r = X,
+    productMetafields: s = [],
+    variantMetafields: i = []
+  } = e, n = s.length > 0, c = i.length > 0, u = ["$ids: [ID!]!"];
+  return n && u.push("$productMetafields: [HasMetafieldsIdentifier!]!"), c && u.push("$variantMetafields: [HasMetafieldsIdentifier!]!"), `
+    ${ut({
+    maxImages: t,
+    maxVariants: r,
+    includeProductMetafields: n,
+    includeVariantMetafields: c
+  })}
+
+    query ProductsByIds(${u.join(", ")}) {
+      nodes(ids: $ids) {
+        ... on Product {
+          ...ProductFields
+        }
+      }
+    }
+  `;
+}
+function ft(e = {}) {
+  const {
+    maxImages: t = z,
+    maxVariants: r = X,
+    productMetafields: s = [],
+    variantMetafields: i = [],
+    collectionMetafields: n = [],
+    includeFilters: c = !1
+  } = e, u = s.length > 0, d = i.length > 0, y = n.length > 0, I = u || d || y, R = ["$ids: [ID!]!", "$handle: String!"];
+  return u && R.push("$productMetafields: [HasMetafieldsIdentifier!]!"), d && R.push("$variantMetafields: [HasMetafieldsIdentifier!]!"), y && R.push("$collectionMetafields: [HasMetafieldsIdentifier!]!"), `
+    ${[
+    ce,
+    Me,
+    Fe,
+    Pe,
+    Se,
+    ie,
+    I ? ee : "",
+    c ? Le : "",
+    c ? Ve : "",
+    Re(d),
+    we({
+      maxImages: t,
+      maxVariants: r,
+      includeProductMetafields: u
+    }),
+    Ge(y)
+  ].join(`
+`)}
+
+    query CollectionWithProducts(${R.join(", ")}) {
+      collection(handle: $handle) {
+        ...CollectionFields
+        ${c ? "products(first: 1) { filters { ...FilterFields } }" : ""}
+      }
+      nodes(ids: $ids) {
+        ... on Product {
+          ...ProductFields
+        }
+      }
+    }
+  `;
+}
+function gt(e = {}) {
+  const { collectionMetafields: t = [], includeFilters: r = !1 } = e, s = t.length > 0, i = ["$handle: String!"];
+  return s && i.push("$collectionMetafields: [HasMetafieldsIdentifier!]!"), `
+    ${[
+    ce,
+    ie,
+    s ? ee : "",
+    r ? Le : "",
+    r ? Ve : "",
+    Ge(s)
+  ].join(`
+`)}
+
+    query Collection(${i.join(", ")}) {
+      collection(handle: $handle) {
+        ...CollectionFields
+        ${r ? "products(first: 1) { filters { ...FilterFields } }" : ""}
+      }
+    }
+  `;
+}
+function pt(e = {}) {
+  const { pageMetafields: t = [] } = e, r = t.length > 0, s = ["$handle: String!"];
+  return r && s.push("$pageMetafields: [HasMetafieldsIdentifier!]!"), `
+    ${[
+    ie,
+    r ? ee : "",
+    He(r)
+  ].join(`
+`)}
+
+    query Page(${s.join(", ")}) {
+      page(handle: $handle) {
+        ...PageFields
+      }
+    }
+  `;
+}
+function mt(e = {}) {
+  const {
+    maxImages: t = z,
+    maxVariants: r = X,
+    productMetafields: s = [],
+    variantMetafields: i = [],
+    pageMetafields: n = []
+  } = e, c = s.length > 0, u = i.length > 0, d = n.length > 0, y = c || u || d, I = ["$ids: [ID!]!", "$handle: String!"];
+  return c && I.push("$productMetafields: [HasMetafieldsIdentifier!]!"), u && I.push("$variantMetafields: [HasMetafieldsIdentifier!]!"), d && I.push("$pageMetafields: [HasMetafieldsIdentifier!]!"), `
+    ${[
+    ce,
+    Me,
+    Fe,
+    Pe,
+    Se,
+    ie,
+    y ? ee : "",
+    Re(u),
+    we({
+      maxImages: t,
+      maxVariants: r,
+      includeProductMetafields: c
+    }),
+    He(d)
+  ].join(`
+`)}
+
+    query PageWithProducts(${I.join(", ")}) {
+      page(handle: $handle) {
+        ...PageFields
+      }
+      nodes(ids: $ids) {
+        ... on Product {
+          ...ProductFields
+        }
+      }
+    }
+  `;
+}
+function ht({
+  shop: e,
+  token: t,
+  apiVersion: r,
+  customFetch: s = fetch
+}) {
+  const i = `https://${e}/api/${r}/graphql.json`;
+  return {
+    async request(n, { variables: c, signal: u } = {}) {
+      const d = await s(i, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Shopify-Storefront-Access-Token": t
+        },
+        body: JSON.stringify({ query: n, variables: c }),
+        signal: u
+      });
+      if (!d.ok)
+        return {
+          data: null,
+          errors: { message: `HTTP ${d.status}`, networkStatusCode: d.status }
+        };
+      const y = await d.json();
+      return y.errors ? { data: y.data, errors: { graphQLErrors: y.errors } } : { data: y.data };
+    }
+  };
+}
+function pe({ ids: e, maxSize: t }) {
+  const r = [];
+  for (let s = 0; s < e.length; s += t)
+    r.push(e.slice(s, s + t));
+  return r;
+}
+function yt(e) {
+  if (!e.storefrontPublicToken)
+    return m(
+      B({
+        code: "MISSING_CONFIG",
+        message: "storefrontPublicToken is required",
+        field: "storefrontPublicToken",
+        expected: "non-empty string"
+      })
+    );
+  if (!e.shop)
+    return m(
+      B({
+        code: "MISSING_CONFIG",
+        message: "shop is required",
+        field: "shop",
+        expected: "non-empty string"
+      })
+    );
+  const { storefrontApiVersion: t = We } = e, r = ht({
+    shop: e.shop,
+    token: e.storefrontPublicToken,
+    apiVersion: t,
+    customFetch: e.fetch
+  });
+  return N({
+    async getProducts(i) {
+      const {
+        ids: n,
+        productMetafields: c = [],
+        variantMetafields: u = [],
+        maxImages: d = z,
+        maxVariants: y = X,
+        signal: I
+      } = i, R = me(i);
+      if (R.length > 0)
+        return m(C({ operation: "getProducts", fields: R }));
+      if (n.length === 0)
+        return N([]);
+      const l = dt({
+        maxImages: d,
+        maxVariants: y,
+        productMetafields: c,
+        variantMetafields: u
+      }), g = pe({ ids: n, maxSize: le }), o = [];
+      for (const p of g) {
+        const a = { ids: p };
+        c.length > 0 && (a.productMetafields = c), u.length > 0 && (a.variantMetafields = u);
+        const f = await It({ shopifyClient: r, query: l, variables: a, signal: I });
+        if (f.error)
+          return f;
+        o.push(...f.data);
+      }
+      return N(o);
+    },
+    async getCollection(i) {
+      const { handle: n, collectionMetafields: c = [], includeFilters: u = !1, signal: d } = i;
+      if (!n)
+        return m(
+          C({
+            operation: "getCollection",
+            fields: [D("handle", "REQUIRED_FIELD", "handle is required")]
+          })
+        );
+      const y = gt({ collectionMetafields: c, includeFilters: u }), I = { handle: n };
+      c.length > 0 && (I.collectionMetafields = c);
+      try {
+        const { data: R, errors: l } = await r.request(y, { variables: I, signal: d });
+        if (l)
+          return m(Y(l));
+        const g = R;
+        return g.collection ? N(g.collection) : m(
+          L({
+            code: "NOT_FOUND",
+            source: "shopify",
+            message: `Collection not found: ${n}`
+          })
+        );
+      } catch (R) {
+        return m(Z(R));
+      }
+    },
+    async getCollectionWithProducts(i) {
+      const {
+        handle: n,
+        ids: c,
+        productMetafields: u = [],
+        variantMetafields: d = [],
+        collectionMetafields: y = [],
+        includeFilters: I = !1,
+        maxImages: R = z,
+        maxVariants: l = X,
+        signal: g
+      } = i, o = me(i);
+      if (n || o.push(D("handle", "REQUIRED_FIELD", "handle is required")), o.length > 0)
+        return m(
+          C({
+            operation: "getCollectionWithProducts",
+            fields: o
+          })
+        );
+      const p = ft({
+        maxImages: R,
+        maxVariants: l,
+        productMetafields: u,
+        variantMetafields: d,
+        collectionMetafields: y,
+        includeFilters: I
+      }), a = c.length > 0 ? pe({ ids: c, maxSize: le }) : [[]];
+      let f = null;
+      const h = [];
+      for (let v = 0; v < a.length; v++) {
+        const b = { ids: a[v], handle: n };
+        u.length > 0 && (b.productMetafields = u), d.length > 0 && (b.variantMetafields = d), y.length > 0 && (b.collectionMetafields = y);
+        try {
+          const { data: E, errors: S } = await r.request(p, { variables: b, signal: g });
+          if (S)
+            return m(Y(S));
+          const w = E;
+          if (v === 0 && (f = w.collection ?? null, !f))
+            return m(
+              L({
+                code: "NOT_FOUND",
+                source: "shopify",
+                message: `Collection not found: ${n}`
+              })
+            );
+          const F = (w.nodes ?? []).filter((T) => T !== null);
+          h.push(...F);
+        } catch (E) {
+          return m(Z(E));
+        }
+      }
+      return N({ collection: f, products: h });
+    },
+    async getPage(i) {
+      const { handle: n, pageMetafields: c = [], signal: u } = i;
+      if (!n)
+        return m(
+          C({
+            operation: "getPage",
+            fields: [D("handle", "REQUIRED_FIELD", "handle is required")]
+          })
+        );
+      const d = pt({ pageMetafields: c }), y = { handle: n };
+      c.length > 0 && (y.pageMetafields = c);
+      try {
+        const { data: I, errors: R } = await r.request(d, { variables: y, signal: u });
+        if (R)
+          return m(Y(R));
+        const l = I;
+        return l.page ? N(l.page) : m(
+          L({
+            code: "NOT_FOUND",
+            source: "shopify",
+            message: `Page not found: ${n}`
+          })
+        );
+      } catch (I) {
+        return m(Z(I));
+      }
+    },
+    async getPageWithProducts(i) {
+      const {
+        handle: n,
+        ids: c,
+        productMetafields: u = [],
+        variantMetafields: d = [],
+        pageMetafields: y = [],
+        maxImages: I = z,
+        maxVariants: R = X,
+        signal: l
+      } = i, g = me(i);
+      if (n || g.push(D("handle", "REQUIRED_FIELD", "handle is required")), g.length > 0)
+        return m(
+          C({ operation: "getPageWithProducts", fields: g })
+        );
+      const o = mt({
+        maxImages: I,
+        maxVariants: R,
+        productMetafields: u,
+        variantMetafields: d,
+        pageMetafields: y
+      }), p = c.length > 0 ? pe({ ids: c, maxSize: le }) : [[]];
+      let a = null;
+      const f = [];
+      for (let h = 0; h < p.length; h++) {
+        const M = { ids: p[h], handle: n };
+        u.length > 0 && (M.productMetafields = u), d.length > 0 && (M.variantMetafields = d), y.length > 0 && (M.pageMetafields = y);
+        try {
+          const { data: b, errors: E } = await r.request(o, { variables: M, signal: l });
+          if (E)
+            return m(Y(E));
+          const S = b;
+          if (h === 0 && (a = S.page ?? null, !a))
+            return m(
+              L({
+                code: "NOT_FOUND",
+                source: "shopify",
+                message: `Page not found: ${n}`
+              })
+            );
+          const w = (S.nodes ?? []).filter((F) => F !== null);
+          f.push(...w);
+        } catch (b) {
+          return m(Z(b));
+        }
+      }
+      return N({ page: a, products: f });
+    }
+  });
+}
+function me(e) {
+  const t = [];
+  e.maxImages !== void 0 && (e.maxImages < fe || e.maxImages > ue) && t.push(
+    D(
+      "maxImages",
+      "OUT_OF_RANGE",
+      `maxImages must be between ${fe} and ${ue}`,
+      {
+        value: e.maxImages,
+        constraints: { min: fe, max: ue }
+      }
+    )
+  ), e.maxVariants !== void 0 && (e.maxVariants < ge || e.maxVariants > de) && t.push(
+    D(
+      "maxVariants",
+      "OUT_OF_RANGE",
+      `maxVariants must be between ${ge} and ${de}`,
+      {
+        value: e.maxVariants,
+        constraints: { min: ge, max: de }
+      }
+    )
+  );
+  for (const r of e.productMetafields ?? [])
+    (!r.namespace || !r.key) && t.push(
+      D(
+        "productMetafields",
+        "REQUIRED_FIELD",
+        "Metafield identifier requires both namespace and key",
+        {
+          value: r,
+          expected: "{ namespace: string, key: string }"
+        }
+      )
+    );
+  for (const r of e.variantMetafields ?? [])
+    (!r.namespace || !r.key) && t.push(
+      D(
+        "variantMetafields",
+        "REQUIRED_FIELD",
+        "Metafield identifier requires both namespace and key",
+        {
+          value: r,
+          expected: "{ namespace: string, key: string }"
+        }
+      )
+    );
+  return t;
+}
+async function It({
+  shopifyClient: e,
+  query: t,
+  variables: r,
+  signal: s
+}) {
+  try {
+    const { data: i, errors: n } = await e.request(t, { variables: r, signal: s });
+    if (n)
+      return m(Y(n));
+    const c = (i?.nodes ?? []).filter(
+      (u) => u !== null
+    );
+    return N(c);
+  } catch (i) {
+    return m(Z(i));
+  }
+}
+function Y(e) {
+  const t = e.networkStatusCode;
+  return t === 401 ? L({
+    code: "UNAUTHORIZED",
+    source: "shopify",
+    message: "Unauthorized: Invalid or missing storefront access token",
+    status: t
+  }) : t === 403 ? L({
+    code: "FORBIDDEN",
+    source: "shopify",
+    message: "Forbidden: Access denied to the requested resource",
+    status: t
+  }) : t === 429 ? L({
+    code: "RATE_LIMITED",
+    source: "shopify",
+    message: "Rate limited: Too many requests to the Storefront API",
+    status: t
+  }) : t !== void 0 && t >= 500 ? L({
+    code: "SERVICE_UNAVAILABLE",
+    source: "shopify",
+    message: `Shopify service error: ${e.message ?? `HTTP ${t}`}`,
+    status: t
+  }) : L({
+    code: "GRAPHQL_ERROR",
+    source: "shopify",
+    message: e.message ?? "GraphQL request failed",
+    status: t,
+    details: {
+      graphqlErrors: e.graphQLErrors?.map((r) => ({
+        message: r.message,
+        path: r.path,
+        extensions: r.extensions
+      }))
+    }
+  });
+}
+function Z(e) {
+  if (e instanceof Error && (e.name === "AbortError" || e.name === "TimeoutError")) {
+    const t = e.name === "TimeoutError" || e.message.includes("timeout");
+    return oe({
+      code: t ? "TIMEOUT" : "ABORTED",
+      message: t ? "Request timed out" : "Request was aborted",
+      cause: e
+    });
+  }
+  return oe({
+    code: "CONNECTION_FAILED",
+    message: e instanceof Error ? e.message : "Network request failed",
+    cause: e
+  });
+}
+const Ne = 1, Et = "cb-sdk-store";
+function he() {
+  return typeof window > "u" || !window.localStorage ? null : window.localStorage;
+}
+function _t(e) {
+  typeof requestIdleCallback == "function" ? requestIdleCallback(e, { timeout: 1e3 }) : setTimeout(e, 0);
+}
+function Ce(e) {
+  return [...e].sort((t, r) => r[1].timestamp - t[1].timestamp);
+}
+function bt({
+  storageKey: e = Et,
+  maxProducts: t = ke,
+  maxQueries: r = $e
+} = {}) {
+  return {
+    save(s) {
+      const i = he();
+      i && _t(() => {
+        try {
+          const n = {
+            products: Ce(s.products).slice(
+              0,
+              t
+            ),
+            queries: Ce(s.queries).slice(0, r),
+            collections: s.collections,
+            version: Ne
+          };
+          i.setItem(e, JSON.stringify(n));
+        } catch {
+        }
+      });
+    },
+    restore() {
+      const s = he();
+      if (!s) return null;
+      try {
+        const i = s.getItem(e);
+        if (!i) return null;
+        const n = JSON.parse(i);
+        return n.version !== Ne || !Array.isArray(n.products) || !Array.isArray(n.queries) ? (s.removeItem(e), null) : n;
+      } catch {
+        return s.removeItem(e), null;
+      }
+    },
+    clear() {
+      he()?.removeItem(e);
+    }
+  };
+}
+function vt(e, t) {
+  if (e.size <= t) return;
+  const s = [...e.entries()].sort((i, n) => i[1].timestamp - n[1].timestamp).slice(0, e.size - t);
+  for (const [i] of s)
+    e.delete(i);
+}
+function Mt(e, t) {
+  if (e.size <= t) return;
+  const r = [];
+  for (const [i, n] of e)
+    n.value && r.push([i, n.value.timestamp]);
+  r.sort((i, n) => i[1] - n[1]);
+  const s = r.slice(0, e.size - t);
+  for (const [i] of s) {
+    const n = e.get(i);
+    n && (n.value = null), e.delete(i);
+  }
+}
+function Ft(e = {}) {
+  const {
+    ttl: t = Xe,
+    maxProducts: r = ke,
+    maxQueries: s = $e,
+    storageKey: i
+  } = e, n = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), y = bt({ storageKey: i, maxProducts: r, maxQueries: s });
+  function I(l) {
+    return Date.now() - l > t;
+  }
+  function R(l) {
+    let g = d.get(l);
+    return g || (g = j(null), d.set(l, g)), g;
+  }
+  return {
+    products: {
+      get(l) {
+        const g = n.get(l);
+        if (g) {
+          if (I(g.timestamp)) {
+            n.delete(l);
+            return;
+          }
+          return g.data;
+        }
+      },
+      getMany(l) {
+        const g = [], o = [];
+        for (const p of l) {
+          const a = n.get(p);
+          a && !I(a.timestamp) ? g.push(a.data) : o.push(p);
+        }
+        return { cached: g, missing: o };
+      },
+      set(l) {
+        const g = Date.now();
+        for (const o of l)
+          n.set(o.gid, { data: o, timestamp: g });
+        vt(n, r);
+      },
+      has(l) {
+        const g = n.get(l);
+        return g != null && !I(g.timestamp);
+      }
+    },
+    queries: {
+      get(l) {
+        return R(l);
+      },
+      set(l, g) {
+        const o = R(l);
+        o.value = { data: g, timestamp: Date.now() }, Mt(d, s);
+      },
+      isExpired(l) {
+        const g = d.get(l);
+        return g?.value ? I(g.value.timestamp) : !0;
+      },
+      invalidate(l) {
+        for (const [g, o] of d)
+          g.includes(l) && (o.value = null);
+      }
+    },
+    collections: {
+      get(l) {
+        return c.get(l);
+      },
+      set(l, g) {
+        c.set(l, { ...g, handle: l });
+      },
+      delete(l) {
+        c.delete(l);
+      }
+    },
+    pages: {
+      get(l) {
+        return u.get(l);
+      },
+      set(l, g) {
+        u.set(l, { ...g, handle: l });
+      },
+      delete(l) {
+        u.delete(l);
+      }
+    },
+    persist() {
+      const l = [], g = [], o = [];
+      for (const [p, a] of n)
+        I(a.timestamp) || l.push([p, a]);
+      for (const [p, a] of d)
+        a.value && !I(a.value.timestamp) && g.push([p, a.value]);
+      for (const [p, a] of c)
+        o.push([p, a]);
+      y.save({ products: l, queries: g, collections: o });
+    },
+    restore() {
+      const l = y.restore();
+      if (l) {
+        for (const [g, o] of l.products)
+          I(o.timestamp) || n.set(g, o);
+        for (const [g, o] of l.queries)
+          if (!I(o.timestamp)) {
+            const p = R(g);
+            p.value = o;
+          }
+        for (const [g, o] of l.collections)
+          c.set(g, o);
+      }
+    },
+    clear() {
+      n.clear();
+      for (const l of d.values()) l.value = null;
+      d.clear(), c.clear(), u.clear(), y.clear();
+    },
+    get stats() {
+      return {
+        products: n.size,
+        queries: d.size,
+        collections: c.size,
+        pages: u.size
+      };
+    }
+  };
+}
+function Te(e, t = []) {
+  return Object.entries(e).filter(([r, s]) => s != null && !t.includes(r)).sort(([r], [s]) => r.localeCompare(s)).map(
+    ([r, s]) => `${encodeURIComponent(r)}=${encodeURIComponent(typeof s == "object" ? JSON.stringify(s) : String(s))}`
+  ).join("&");
+}
+function Pt(e, t = {}) {
+  if (!e?.trim()) return;
+  const r = `/browse/${encodeURIComponent(e)}`, s = Te(t, ["collectionHandle", "signal"]);
+  return s ? `${r}?${s}` : r;
+}
+function St(e, t = {}) {
+  if (!e?.trim()) return;
+  const r = `/search/${encodeURIComponent(e)}`, s = Te(t, ["query", "signal"]);
+  return s ? `${r}?${s}` : r;
+}
+function Rt(e, t = {}) {
+  if (!e?.trim()) return;
+  const r = `/blocks/${encodeURIComponent(e)}`, s = Te(t, ["blockId", "signal"]);
+  return s ? `${r}?${s}` : r;
+}
+function wt(e, t = {}) {
+  const { currencyCode: r = "USD", formatPrice: s = Tt, swatches: i = [] } = t, n = Ue(e), c = ye(e), u = e.title, d = e.handle ?? "", y = e.vendor ?? "", I = e.product_type ?? "", R = e.body_html ?? "", l = e.available ?? !1, g = e.is_gift_card ?? !1, o = $t(e), p = e.tags ?? [], a = At(e), f = Dt(e.price_range, r, s), h = Ot(e, i), v = Nt(e, r, s), M = v.map((F) => F.compareAtPrice).filter((F) => F !== null), b = M.length > 0 ? {
+    min: M.reduce((F, T) => F.amount < T.amount ? F : T),
+    max: M.reduce((F, T) => F.amount > T.amount ? F : T)
+  } : void 0, E = e.first_or_matched_variant ? qt(e.first_or_matched_variant) : [], S = xe({ type: "Product", selectedOptions: E }), w = e.metafields ?? {};
+  return {
+    id: S,
+    gid: c,
+    numericId: n,
+    title: u,
+    handle: d,
+    type: I,
+    vendor: y,
+    description: R,
+    availableForSale: l,
+    images: a,
+    priceRange: f,
+    compareAtPriceRange: b,
+    options: h,
+    tags: p,
+    variants: v,
+    selectedOptions: E,
+    metafields: w,
+    calculated: e.calculated,
+    isGiftCard: g,
+    onlineStoreUrl: null,
+    totalInventory: o
+  };
+}
+function Tt(e, t) {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: t
+  }).format(e);
+}
+function At(e) {
+  return (e.images ?? []).map((t) => ({
+    url: t.src,
+    alt: t.alt ?? "",
+    width: t.width,
+    height: t.height
+  }));
+}
+function Dt(e, t, r) {
+  const s = e?.from ?? 0, i = e?.to ?? s;
+  return {
+    min: { amount: s, currencyCode: t, formatted: r(s, t) },
+    max: { amount: i, currencyCode: t, formatted: r(i, t) }
+  };
+}
+function Ot(e, t) {
+  const r = [], s = e.options ?? {};
+  for (const [i, n] of Object.entries(s))
+    for (const c of n) {
+      const u = t.find((d) => d.name === i && d.value === c);
+      r.push({ name: i, value: c, swatch: u });
+    }
+  return r;
+}
+function qt(e) {
+  return e.selected_options.map((t) => ({ name: t.name, value: t.value }));
+}
+function Nt(e, t, r) {
+  return (e.variants ?? []).map((s) => Ct(s, t, r));
+}
+function Ct(e, t, r) {
+  const s = parseFloat(e.price), i = e.compare_at_price ? parseFloat(e.compare_at_price) : null;
+  return {
+    id: xe({ type: "ProductVariant", selectedOptions: e.selected_options }),
+    gid: `gid://shopify/ProductVariant/${e.id}`,
+    numericId: e.id,
+    title: e.title,
+    availableForSale: e.available,
+    currentlyNotInStock: !e.available,
+    quantityAvailable: e.inventory_quantity ?? 0,
+    sku: e.sku ?? null,
+    barcode: null,
+    weight: null,
+    weightUnit: null,
+    requiresShipping: !0,
+    price: { amount: s, currencyCode: t, formatted: r(s, t) },
+    compareAtPrice: i != null ? {
+      amount: i,
+      currencyCode: t,
+      formatted: r(i, t)
+    } : null,
+    image: e.featured_media ? {
+      url: e.featured_media.src,
+      alt: e.featured_media.alt ?? "",
+      width: e.featured_media.width,
+      height: e.featured_media.height
+    } : null,
+    selectedOptions: e.selected_options.map((n) => ({ name: n.name, value: n.value })),
+    metafields: kt(e.metafields)
+  };
+}
+function kt(e) {
+  return e ? e.map((t) => ({
+    namespace: t.namespace,
+    key: t.key,
+    value: t.value,
+    type: t.value_type
+  })) : [];
+}
+function $t(e) {
+  const t = e.first_or_matched_variant;
+  return t?.inventory_quantity != null ? t.inventory_quantity : 0;
+}
+var Ie = /* @__PURE__ */ ((e) => (e.Equal = "eq", e.NotEqual = "not_eq", e.In = "in", e.NotIn = "not_in", e.GreaterThan = "gt", e.GreaterThanOrEqual = "gte", e.LessThan = "lt", e.LessThanOrEqual = "lte", e.Exists = "exists", e.NotExists = "not_exists", e))(Ie || {}), Qe = /* @__PURE__ */ ((e) => (e.And = "AND", e.Or = "OR", e))(Qe || {});
+function Wt(e, t) {
+  return { property: e, operator: "eq", values: [t] };
+}
+function Kt(e, t) {
+  return { property: e, operator: "not_eq", values: [t] };
+}
+function zt(e, t) {
+  return { property: e, operator: "in", values: t };
+}
+function Xt(e, t) {
+  return { property: e, operator: "not_in", values: t };
+}
+function Jt(e, t) {
+  return { property: e, operator: "gt", values: [t] };
+}
+function Yt(e, t) {
+  return { property: e, operator: "gte", values: [t] };
+}
+function Zt(e, t) {
+  return { property: e, operator: "lt", values: [t] };
+}
+function er(e, t) {
+  return { property: e, operator: "lte", values: [t] };
+}
+function tr(e) {
+  return { property: e, operator: "exists", values: [] };
+}
+function rr(e) {
+  return { property: e, operator: "not_exists", values: [] };
+}
+function xt(...e) {
+  return { conditional: "AND", expressions: e };
+}
+function nr(...e) {
+  return { conditional: "OR", expressions: e };
+}
+function Ut(e) {
+  return "conditional" in e;
+}
+function sr(e) {
+  return { filter_group: Ut(e) ? e : xt(e) };
+}
+function je() {
+  return typeof window < "u" && typeof window.document < "u";
+}
+const Be = "__COMMERCE_BLOCKS__";
+function Lt(e) {
+  je() && (window[Be] = e);
+}
+function Vt() {
+  if (!je())
+    return m(
+      B({
+        code: "INVALID_CONFIG",
+        message: "SDK only available in browser",
+        field: "environment",
+        expected: "browser"
+      })
+    );
+  const e = window[Be];
+  return e ? N(e) : m(
+    B({
+      code: "MISSING_CONFIG",
+      message: "SDK not initialized. Call createSdk() first.",
+      field: "sdk"
+    })
+  );
+}
+function or() {
+  return Vt().data !== void 0;
+}
+function ne(e) {
+  const t = new AbortController();
+  return e && (e.aborted ? t.abort(e.reason) : e.addEventListener("abort", () => t.abort(e.reason), { once: !0 })), t;
+}
+function Gt(e, t) {
+  let r = null;
+  return {
+    call(...s) {
+      r && clearTimeout(r), r = setTimeout(() => e(...s), t);
+    },
+    cancel() {
+      r && clearTimeout(r);
+    }
+  };
+}
+function se(e, t, r) {
+  const s = {
+    products: e,
+    totalResults: t.totalResults,
+    totalPages: t.totalPages,
+    page: t.page,
+    facets: t.facets ?? {}
+  };
+  return r ? r(s, t) : s;
+}
+function Ht(e) {
+  return {
+    id: "",
+    handle: e.handle,
+    title: e.title ?? "",
+    description: e.description ?? "",
+    descriptionHtml: e.descriptionHtml ?? "",
+    image: e.image ? {
+      url: e.image.url,
+      altText: e.image.alt ?? null,
+      width: e.image.width ?? 0,
+      height: e.image.height ?? 0
+    } : null,
+    seo: { title: null, description: null },
+    updatedAt: "",
+    metafields: e.metafields
+  };
+}
+function ar(e) {
+  const t = lt({
+    layersPublicToken: e.layersPublicToken,
+    layersBaseUrl: e.layersBaseUrl,
+    sorts: e.sorts,
+    facets: e.facets,
+    attributes: e.attributes,
+    fetch: e.fetch
+  });
+  if (t.error) return m(t.error);
+  const r = t.data;
+  let s, i = !1;
+  if (e.enableStorefront) {
+    if (!e.shop || !e.storefrontPublicToken)
+      return m(
+        B({
+          code: "MISSING_CONFIG",
+          message: "shop and storefrontPublicToken are required when enableStorefront is true",
+          field: e.shop ? "storefrontPublicToken" : "shop",
+          expected: "non-empty string"
+        })
+      );
+    const o = yt({
+      shop: e.shop,
+      storefrontPublicToken: e.storefrontPublicToken,
+      storefrontApiVersion: e.storefrontApiVersion,
+      fetch: e.fetch
+    });
+    if (o.error) return m(o.error);
+    s = o.data, i = !0;
+  }
+  const n = Ft({
+    maxProducts: e.cacheMaxProducts,
+    maxQueries: e.cacheMaxEntries,
+    ttl: e.cacheTtl
+  }), c = {
+    currencyCode: e.currencyCode,
+    formatPrice: e.formatPrice,
+    swatches: e.swatches
+  };
+  function u(o) {
+    return o.map(ye);
+  }
+  function d(o, p) {
+    const a = wt(o, c);
+    return e.extendProduct ? { ...e.extendProduct({ base: a, raw: o, shopify: p }), _base: a } : a;
+  }
+  function y(o, p, a) {
+    return o.map((f) => {
+      const h = ye(f), v = a.get(h);
+      return v || d(f, p.get(h) ?? null);
+    });
+  }
+  async function I(o, p = e.productMetafields, a = e.variantMetafields) {
+    const f = /* @__PURE__ */ new Map();
+    if (!i || o.length === 0) return f;
+    const h = await s.getProducts({
+      ids: o,
+      productMetafields: p,
+      variantMetafields: a
+    });
+    if (h.error)
+      return console.warn("[SDK] Failed to fetch storefront products:", h.error.message), f;
+    for (const v of h.data)
+      f.set(v.id, v);
+    return f;
+  }
+  async function R(o) {
+    const p = u(o), { cached: a, missing: f } = n.products.getMany(p), h = new Map(a.map((M) => [M.gid, M]));
+    if (f.length === 0)
+      return p.map((M) => h.get(M));
+    const v = await I(f);
+    return y(o, v, h);
+  }
+  function l(o) {
+    if (o) {
+      if (e.transformFilters)
+        return e.transformFilters(o);
+      if (e.filterMap && typeof o == "object" && !Array.isArray(o)) {
+        const p = o, a = [];
+        for (const [f, h] of Object.entries(p)) {
+          if (h == null) continue;
+          const v = e.filterMap[f], M = typeof v == "string" ? v : v?.property ?? f, b = typeof v == "object" ? v.values : void 0, S = (Array.isArray(h) ? h : [h]).map((w) => {
+            const F = String(w);
+            return b?.[F] ?? F;
+          });
+          a.push({
+            property: M,
+            operator: S.length > 1 ? Ie.In : Ie.Equal,
+            values: S
+          });
+        }
+        return a.length === 0 ? void 0 : {
+          conditional: Qe.And,
+          expressions: a
+        };
+      }
+      return o;
+    }
+  }
+  const g = {
+    config: e,
+    store: n,
+    autocomplete({ debounceMs: o = 300, signal: p } = {}) {
+      const a = j({
+        data: null,
+        error: null,
+        isFetching: !1
+      });
+      let f = null;
+      const h = /* @__PURE__ */ new Map();
+      function v() {
+        M.cancel(), f?.abort();
+      }
+      p?.addEventListener("abort", v, { once: !0 });
+      const M = Gt(async (b) => {
+        if (!b.trim()) {
+          a.value = { data: null, error: null, isFetching: !1 };
+          return;
+        }
+        const E = b.trim().toLowerCase(), S = h.get(E);
+        if (S) {
+          a.value = { data: S, error: null, isFetching: !1 };
+          return;
+        }
+        f?.abort(), f = ne(p), a.value = { ...a.value, isFetching: !0 };
+        const w = await r.predictiveSearch(b.trim(), f.signal);
+        w.error ? w.error._tag !== "NetworkError" || w.error.code !== "ABORTED" ? a.value = { data: null, error: w.error, isFetching: !1 } : a.value = { ...a.value, isFetching: !1 } : (h.set(E, w.data), a.value = { data: w.data, error: null, isFetching: !1 });
+      }, o);
+      return { state: a, execute: (b) => M.call(b), dispose: v };
+    },
+    search() {
+      const o = j({
+        data: null,
+        error: null,
+        isFetching: !1
+      });
+      let p = null, a;
+      return {
+        state: o,
+        async prepare(f) {
+          const { query: h, filters: v, tuning: M, signal: b } = f, E = l(v), S = await r.prepareSearch(
+            { query: h, filter_group: E, tuning: M },
+            b
+          );
+          return S.error ? m(S.error) : (a = S.data.search_id, N({ searchId: S.data.search_id }));
+        },
+        async execute(f) {
+          const {
+            query: h,
+            searchId: v,
+            page: M = 1,
+            limit: b = 24,
+            filters: E,
+            tuning: S,
+            signal: w
+          } = f, F = l(E);
+          p?.abort(), p = ne(w), o.value = { ...o.value, isFetching: !0, error: null };
+          let T = v ?? a;
+          if (a = void 0, !T) {
+            const _ = await r.prepareSearch(
+              { query: h, filter_group: F, tuning: S },
+              p.signal
+            );
+            if (_.error)
+              return o.value = { ...o.value, isFetching: !1, error: _.error }, m(_.error);
+            T = _.data.search_id;
+          }
+          const A = 20;
+          let P = await r.search(
+            {
+              query: h,
+              search_id: T,
+              pagination: { page: M, limit: b },
+              filter_group: F,
+              tuning: S
+            },
+            p.signal
+          );
+          for (let _ = 0; _ < A && P.error; _++) {
+            const V = P.error;
+            if (V._tag !== "ApiError" || V.status !== 425) break;
+            let H = 50;
+            try {
+              const G = JSON.parse(V.message);
+              G.retry_after_ms && (H = G.retry_after_ms);
+            } catch {
+            }
+            await new Promise((G) => setTimeout(G, H)), P = await r.search(
+              {
+                query: h,
+                search_id: T,
+                pagination: { page: M, limit: b },
+                filter_group: F,
+                tuning: S
+              },
+              p.signal
+            );
+          }
+          if (o.value = { ...o.value, isFetching: !1 }, P.error)
+            return o.value = { ...o.value, error: P.error }, m(P.error);
+          const { results: x } = P.data, $ = await R(x), O = se($, P.data, e.extendSearch);
+          e.includeMeta && P.data._meta && (O._meta = P.data._meta), n.products.set($);
+          const U = St(h, { page: M, limit: b, filters: E });
+          return U && n.queries.set(U, O), o.value = { ...o.value, data: O }, N(O);
+        },
+        dispose() {
+          p?.abort();
+        }
+      };
+    },
+    collection({
+      handle: o,
+      defaultSort: p
+    }) {
+      const a = j({
+        data: null,
+        error: null,
+        isFetching: !1
+      });
+      let f = null, h = p ?? e.sorts[0]?.code;
+      return {
+        state: a,
+        async execute(v = {}) {
+          const {
+            page: M = 1,
+            limit: b = 24,
+            filters: E,
+            sortOrderCode: S,
+            signal: w,
+            includeMeta: F = e.includeMeta ?? !1,
+            collectionMetafields: T = e.collectionMetafields,
+            includeFilters: A
+          } = v, P = S ?? h;
+          h = P, f?.abort(), f = ne(w);
+          const x = a.value.data;
+          a.value = { data: x, error: null, isFetching: !0 };
+          const { data: $, error: O } = await r.browse(
+            {
+              collectionHandle: o,
+              sort_order_code: P,
+              pagination: { page: M, limit: b },
+              filter_group: l(E)
+            },
+            f.signal
+          );
+          if (O)
+            return a.value = { data: x, error: O, isFetching: !1 }, m(O);
+          const { results: U } = $, _ = U, V = u(_), { cached: H, missing: G } = n.products.getMany(V), te = new Map(H.map((k) => [k.gid, k])), Ae = F && !T?.length ? n.collections.get(o) : void 0, De = Ae?.title !== void 0;
+          let W, q;
+          if (G.length === 0)
+            W = V.map((k) => te.get(k));
+          else if (i && F && !De) {
+            const k = await s.getCollectionWithProducts({
+              handle: o,
+              ids: G,
+              productMetafields: e.productMetafields,
+              variantMetafields: e.variantMetafields,
+              collectionMetafields: T,
+              includeFilters: A
+            });
+            if (k.data) {
+              q = k.data.collection;
+              const re = /* @__PURE__ */ new Map();
+              for (const qe of k.data.products)
+                re.set(qe.id, qe);
+              W = y(_, re, te);
+            } else {
+              const re = await I(G);
+              W = y(_, re, te);
+            }
+          } else {
+            const k = await I(G);
+            W = y(_, k, te);
+          }
+          if (i && F && !q)
+            if (De)
+              q = Ht(Ae);
+            else {
+              const k = await s.getCollection({
+                handle: o,
+                collectionMetafields: T,
+                includeFilters: A
+              });
+              k.data && (q = k.data);
+            }
+          const Q = se(
+            W,
+            $,
+            e.extendCollection
+          );
+          F && $._meta && (Q._meta = $._meta), q && (Q.collection = q);
+          const Oe = Pt(o, { sortOrderCode: P, page: M, limit: b, filters: E });
+          return Oe && n.queries.set(Oe, Q), n.products.set(W), n.collections.set(o, {
+            totalProducts: Q.totalResults,
+            totalPages: Q.totalPages,
+            lastPageFetched: M,
+            facets: Q.facets,
+            lastFetched: Date.now(),
+            ...q && {
+              title: q.title,
+              description: q.description,
+              descriptionHtml: q.descriptionHtml,
+              image: q.image ? {
+                url: q.image.url,
+                alt: q.image.altText ?? void 0,
+                width: q.image.width,
+                height: q.image.height
+              } : void 0,
+              metafields: q.metafields
+            }
+          }), a.value = { data: Q, error: null, isFetching: !1 }, N(Q);
+        },
+        dispose() {
+          f?.abort();
+        }
+      };
+    },
+    blocks({
+      blockId: o,
+      anchorId: p,
+      anchorHandle: a
+    }) {
+      const f = j({
+        data: null,
+        error: null,
+        isFetching: !1
+      });
+      let h = null;
+      return {
+        state: f,
+        async execute(v = {}) {
+          const {
+            page: M = 1,
+            limit: b = 24,
+            filters: E,
+            signal: S,
+            discountEntitlements: w,
+            context: F
+          } = v;
+          h?.abort(), h = ne(S);
+          const T = f.value.data;
+          f.value = { data: T, error: null, isFetching: !0 };
+          const { data: A, error: P } = await r.blocks(
+            {
+              blockId: o,
+              anchor_id: p,
+              anchor_handle: a,
+              pagination: { page: M, limit: b },
+              filter_group: l(E),
+              discountEntitlements: w,
+              context: F
+            },
+            h.signal
+          );
+          if (P)
+            return f.value = { data: T, error: P, isFetching: !1 }, m(P);
+          const { results: x } = A, $ = await R(x), O = se(
+            $,
+            A,
+            e.extendBlock
+          );
+          e.includeMeta && A._meta && (O._meta = A._meta), A.block && (O.block = A.block);
+          const U = Rt(o, { anchorId: p, anchorHandle: a, page: M, limit: b, filters: E });
+          return U && n.queries.set(U, O), n.products.set($), f.value = { data: O, error: null, isFetching: !1 }, N(O);
+        },
+        dispose() {
+          h?.abort();
+        }
+      };
+    },
+    uploadImage({
+      image: o,
+      signal: p
+    }) {
+      const a = j({
+        data: null,
+        error: null,
+        isFetching: !0
+      });
+      return (async () => {
+        const f = await r.uploadImage(o, p);
+        if (f.error) {
+          a.value = { data: null, error: f.error, isFetching: !1 };
+          return;
+        }
+        a.value = { data: { imageId: f.data.imageId }, error: null, isFetching: !1 };
+      })(), a;
+    },
+    imageSearch(o) {
+      const { imageId: p, page: a = 1, limit: f = 24, filters: h, tuning: v, signal: M } = o, b = j({
+        data: null,
+        error: null,
+        isFetching: !0
+      });
+      return (async () => {
+        const E = await r.imageSearch(
+          {
+            image_id: p,
+            pagination: { page: a, limit: f },
+            filter_group: l(h),
+            tuning: v
+          },
+          M
+        );
+        if (E.error) {
+          b.value = { data: null, error: E.error, isFetching: !1 };
+          return;
+        }
+        const { results: S } = E.data, w = await R(S), F = se(w, E.data, e.extendSearch);
+        n.products.set(w), b.value = { data: F, error: null, isFetching: !1 };
+      })(), b;
+    },
+    storefront(o) {
+      const {
+        ids: p,
+        meta: a,
+        productMetafields: f = e.productMetafields,
+        variantMetafields: h = e.variantMetafields,
+        collectionMetafields: v = e.collectionMetafields,
+        pageMetafields: M = e.pageMetafields,
+        signal: b
+      } = o, E = j({
+        data: null,
+        error: null,
+        isFetching: !1
+      });
+      if (p.length === 0)
+        return E.value = { data: { products: [] }, error: null, isFetching: !1 }, E;
+      const S = p, { cached: w, missing: F } = n.products.getMany(S);
+      if (F.length === 0 && !a) {
+        const T = new Map(w.map((P) => [P.gid, P])), A = S.map((P) => T.get(P));
+        return E.value = { data: { products: A }, error: null, isFetching: !1 }, E;
+      }
+      if (!i) {
+        const T = new Map(w.map((P) => [P.gid, P])), A = S.map((P) => T.get(P)).filter((P) => P != null);
+        return E.value = { data: { products: A }, error: null, isFetching: !1 }, E;
+      }
+      return E.value = { data: null, error: null, isFetching: !0 }, (async () => {
+        const T = new Map(w.map((_) => [_.gid, _]));
+        let A = [], P, x;
+        if (a?.collection && F.length > 0) {
+          const _ = await s.getCollectionWithProducts({
+            handle: a.collection,
+            ids: F,
+            productMetafields: f,
+            variantMetafields: h,
+            collectionMetafields: v,
+            includeFilters: a.includeFilters,
+            signal: b
+          });
+          if (_.error) {
+            E.value = { data: null, error: _.error, isFetching: !1 };
+            return;
+          }
+          A = _.data.products, P = _.data.collection;
+        } else if (a?.page && F.length > 0) {
+          const _ = await s.getPageWithProducts({
+            handle: a.page,
+            ids: F,
+            productMetafields: f,
+            variantMetafields: h,
+            pageMetafields: M,
+            signal: b
+          });
+          if (_.error) {
+            E.value = { data: null, error: _.error, isFetching: !1 };
+            return;
+          }
+          A = _.data.products, x = _.data.page;
+        } else if (F.length > 0) {
+          const _ = await s.getProducts({
+            ids: F,
+            productMetafields: f,
+            variantMetafields: h,
+            signal: b
+          });
+          if (_.error) {
+            E.value = { data: null, error: _.error, isFetching: !1 };
+            return;
+          }
+          A = _.data;
+        }
+        if (a?.collection && a?.page) {
+          const _ = await s.getPage({
+            handle: a.page,
+            pageMetafields: M,
+            signal: b
+          });
+          _.data && (x = _.data);
+        }
+        const $ = new Map(A.map((_) => [_.id, _])), O = S.map((_) => {
+          const V = T.get(_);
+          if (V) return V;
+          const H = $.get(_);
+          return H ? d({ id: rt(_) ?? 0, title: H.title }, H) : null;
+        }).filter((_) => _ !== null);
+        n.products.set(O);
+        const U = { products: O };
+        P && (U.collection = P), x && (U.page = x), E.value = { data: U, error: null, isFetching: !1 };
+      })(), E;
+    }
+  };
+  return Lt(g), N(g);
+}
+export {
+  xt as and,
+  lr as batch,
+  ur as computed,
+  ar as createSdk,
+  dr as effect,
+  Wt as eq,
+  tr as exists,
+  sr as filter,
+  Vt as getSdk,
+  Jt as gt,
+  Yt as gte,
+  zt as inValues,
+  or as isInitialized,
+  Bt as isRetryable,
+  jt as isSdkError,
+  Zt as lt,
+  er as lte,
+  Kt as notEq,
+  rr as notExists,
+  Xt as notIn,
+  nr as or,
+  fr as signal
+};