@swell/apps-sdk 1.0.127 → 1.0.129

package/dist/index.js

@@ -89,10 +89,151 @@
   var import_json52 = __toESM(__require("json5"), 1);
 
   // src/resources.ts
-  var import_lodash_es = __require("lodash-es");
+  var import_lodash_es2 = __require("lodash-es");
 
   // src/liquid/utils.ts
   var import_liquidjs = __require("liquidjs");
+
+  // src/compatibility/shopify-objects/resource.ts
+  var import_lodash_es = __require("lodash-es");
+  var ShopifyResource = class _ShopifyResource {
+    props;
+    stringProp;
+    linkProps;
+    constructor(props, stringProp, linkProps) {
+      this.props = props;
+      this.stringProp = stringProp;
+      this.linkProps = linkProps;
+      return new Proxy(props, {
+        get(target, prop, receiver) {
+          const instance = target;
+          switch (prop) {
+            case "toJSON":
+              return props;
+            case "clone":
+              return () => {
+                return new _ShopifyResource(
+                  (0, import_lodash_es.cloneDeep)(props),
+                  (0, import_lodash_es.cloneDeep)(stringProp),
+                  (0, import_lodash_es.cloneDeep)(linkProps)
+                );
+              };
+            case "toString": {
+              if (stringProp) {
+                return () => {
+                  return props[stringProp];
+                };
+              }
+              break;
+            }
+            case Symbol.toPrimitive: {
+              return () => {
+                let prop2 = stringProp;
+                if (typeof prop2 === "number") {
+                  prop2 = prop2.toString();
+                }
+                return this.get?.(instance, prop2 || "handle", receiver);
+              };
+            }
+            default:
+              break;
+          }
+          const value = instance[prop];
+          if (value instanceof DeferredShopifyResource) {
+            const promise = value.resolve().then(
+              (value2) => {
+                instance[prop] = value2;
+                return value2;
+              },
+              (err) => {
+                console.log(err);
+                instance[prop] = null;
+                return null;
+              }
+            );
+            instance[prop] = promise;
+            return promise;
+          }
+          return value;
+        },
+        getPrototypeOf() {
+          return _ShopifyResource.prototype;
+        }
+      });
+    }
+    valueOf() {
+      if (this.stringProp) {
+        return this.props[this.stringProp];
+      }
+      return this;
+    }
+    // For typescript
+    clone() {
+      return new _ShopifyResource(this.props);
+    }
+  };
+  var DeferredShopifyResource = class {
+    handler;
+    result;
+    constructor(handler) {
+      this.result = void 0;
+      this.handler = handler;
+    }
+    async resolve() {
+      if (this.handler !== import_lodash_es.noop) {
+        const handler = this.handler;
+        this.handler = import_lodash_es.noop;
+        this.result = Promise.resolve().then(handler).then((value) => {
+          this.result = value;
+          return value;
+        });
+      }
+      return this.result;
+    }
+  };
+  function defer(handler) {
+    return new DeferredShopifyResource(handler);
+  }
+  function isResolvable(asyncProp) {
+    return isObject(asyncProp) && (isLikePromise(asyncProp) || typeof asyncProp._resolve === "function");
+  }
+  function isStorefrontResource(resource) {
+    return isObject(resource) && typeof resource._resolve === "function";
+  }
+  async function resolveAsyncProp(asyncProp) {
+    if (Array.isArray(asyncProp)) {
+      return Promise.all(
+        asyncProp.map(
+          (prop) => isStorefrontResource(prop) ? prop._resolve() : prop
+        )
+      );
+    }
+    if (isStorefrontResource(asyncProp)) {
+      return asyncProp._resolve();
+    }
+    return asyncProp;
+  }
+  function handleDeferredProp(asyncProp, handler) {
+    return resolveAsyncProp(asyncProp).then((value) => {
+      if (Array.isArray(asyncProp) && Array.isArray(value)) {
+        return handler(...value.map((prop) => prop || {}));
+      }
+      if (isResolvable(value)) {
+        return handleDeferredProp(value, handler);
+      }
+      return handler(value || {});
+    }).catch((err) => {
+      console.log(err);
+      return null;
+    });
+  }
+  function deferWith(asyncProp, handler) {
+    return new DeferredShopifyResource(
+      () => handleDeferredProp(asyncProp, handler)
+    );
+  }
+
+  // src/liquid/utils.ts
   var ForloopDrop = class extends import_liquidjs.Drop {
     i;
     length;
@@ -259,18 +400,24 @@
   async function resolveAllKeys(value, references = /* @__PURE__ */ new WeakSet()) {
     await forEachKeyDeep(value, async (key, value2) => {
       if (!isObject(value2)) {
-        return;
+        return true;
       }
       const val = value2[key];
       if (isLikePromise(val)) {
         value2[key] = await val;
         await resolveAllKeys(value2[key], references);
       } else if (isObject(val)) {
+        if (val instanceof DeferredShopifyResource) {
+          value2[key] = await val.resolve();
+          await resolveAllKeys(value2[key], references);
+          return true;
+        }
         if (references.has(val)) {
           return false;
         }
         references.add(val);
       }
+      return true;
     });
   }
   async function forEachKeyDeep(obj, fn) {
@@ -388,12 +535,18 @@
       }
       return instance[prop];
     }
+    // add additional properties to the loaded result
+    _transformResult(result) {
+      return result;
+    }
     async _get(..._args) {
       if (this._getter) {
         const getter = this._getter.bind(
           this
         );
         return Promise.resolve().then(getter).then((result) => {
+          return this._transformResult(result);
+        }).then((result) => {
           this._result = result;
           if (result) {
             Object.assign(this, result);
@@ -469,6 +622,8 @@
   function cloneStorefrontResource(input) {
     const resourceName = input._resourceName;
     const clone = new StorefrontResource(input._getter);
+    clone._params = input._params;
+    clone._transformResult = input._transformResult.bind(clone);
     Object.defineProperty(clone.constructor, "name", {
       value: resourceName
     });
@@ -596,7 +751,7 @@
         this._getter
       );
       if (this._isResultResolved()) {
-        cloned._result = (0, import_lodash_es.cloneDeep)(this._result);
+        cloned._result = (0, import_lodash_es2.cloneDeep)(this._result);
       }
       if (this._compatibilityProps) {
         cloned.setCompatibilityProps(this._compatibilityProps);
@@ -625,7 +780,7 @@
         }
       });
       if (this._isResultResolved()) {
-        const result = (0, import_lodash_es.cloneDeep)(this._result);
+        const result = (0, import_lodash_es2.cloneDeep)(this._result);
         if (result) {
           const compatibilityProps = compatibilityGetter(result);
           Object.assign(cloned, result);
@@ -639,10 +794,12 @@
   };
   var SwellStorefrontRecord = class extends SwellStorefrontResource {
     _id;
+    _params;
     constructor(swell, collection, id, query = {}, getter) {
       super(swell, collection, getter);
       this._id = id;
       this._query = query;
+      this._params = {};
       if (!getter) {
         this._setGetter(this._defaultGetter());
       }
@@ -680,6 +837,8 @@
           ],
           getter
         ).then((result) => {
+          return this._transformResult(result);
+        }).then((result) => {
           this._result = result;
           if (result) {
             Object.assign(this, result);
@@ -789,145 +948,6 @@
     }
   };
 
-  // src/compatibility/shopify-objects/resource.ts
-  var import_lodash_es2 = __require("lodash-es");
-  var ShopifyResource = class _ShopifyResource {
-    props;
-    stringProp;
-    linkProps;
-    constructor(props, stringProp, linkProps) {
-      this.props = props;
-      this.stringProp = stringProp;
-      this.linkProps = linkProps;
-      return new Proxy(props, {
-        get(target, prop, receiver) {
-          const instance = target;
-          switch (prop) {
-            case "toJSON":
-              return props;
-            case "clone":
-              return () => {
-                return new _ShopifyResource(
-                  (0, import_lodash_es2.cloneDeep)(props),
-                  (0, import_lodash_es2.cloneDeep)(stringProp),
-                  (0, import_lodash_es2.cloneDeep)(linkProps)
-                );
-              };
-            case "toString": {
-              if (stringProp) {
-                return () => {
-                  return props[stringProp];
-                };
-              }
-              break;
-            }
-            case Symbol.toPrimitive: {
-              return () => {
-                let prop2 = stringProp;
-                if (typeof prop2 === "number") {
-                  prop2 = prop2.toString();
-                }
-                return this.get?.(instance, prop2 || "handle", receiver);
-              };
-            }
-            default:
-              break;
-          }
-          const value = instance[prop];
-          if (value instanceof DeferredShopifyResource) {
-            const promise = value.resolve().then(
-              (value2) => {
-                instance[prop] = value2;
-                return value2;
-              },
-              (err) => {
-                console.log(err);
-                instance[prop] = null;
-                return null;
-              }
-            );
-            instance[prop] = promise;
-            return promise;
-          }
-          return value;
-        },
-        getPrototypeOf() {
-          return _ShopifyResource.prototype;
-        }
-      });
-    }
-    valueOf() {
-      if (this.stringProp) {
-        return this.props[this.stringProp];
-      }
-      return this;
-    }
-    // For typescript
-    clone() {
-      return new _ShopifyResource(this.props);
-    }
-  };
-  var DeferredShopifyResource = class {
-    handler;
-    result;
-    constructor(handler) {
-      this.result = void 0;
-      this.handler = handler;
-    }
-    async resolve() {
-      if (this.handler !== import_lodash_es2.noop) {
-        const handler = this.handler;
-        this.handler = import_lodash_es2.noop;
-        this.result = Promise.resolve().then(handler).then((value) => {
-          this.result = value;
-          return value;
-        });
-      }
-      return this.result;
-    }
-  };
-  function defer(handler) {
-    return new DeferredShopifyResource(handler);
-  }
-  function isResolvable(asyncProp) {
-    return isObject(asyncProp) && (isLikePromise(asyncProp) || typeof asyncProp._resolve === "function");
-  }
-  function isStorefrontResource(resource) {
-    return isObject(resource) && typeof resource._resolve === "function";
-  }
-  async function resolveAsyncProp(asyncProp) {
-    if (Array.isArray(asyncProp)) {
-      return Promise.all(
-        asyncProp.map(
-          (prop) => isStorefrontResource(prop) ? prop._resolve() : prop
-        )
-      );
-    }
-    if (isStorefrontResource(asyncProp)) {
-      return asyncProp._resolve();
-    }
-    return asyncProp;
-  }
-  function handleDeferredProp(asyncProp, handler) {
-    return resolveAsyncProp(asyncProp).then((value) => {
-      if (Array.isArray(asyncProp) && Array.isArray(value)) {
-        return handler(...value.map((prop) => prop || {}));
-      }
-      if (isResolvable(value)) {
-        return handleDeferredProp(value, handler);
-      }
-      return handler(value || {});
-    }).catch((err) => {
-      console.log(err);
-      return null;
-    });
-  }
-  function deferWith(asyncProp, handler) {
-    return new DeferredShopifyResource(
-      () => handleDeferredProp(asyncProp, handler)
-    );
-  }
-
   // src/constants.ts
   var FILE_DATA_INCLUDE_QUERY = {
     url: "/:themes:configs/{id}/file/data",
@@ -7012,50 +7032,213 @@
           store: new CFWorkerKVKeyvAdapter(kvStore)
         })
       );
-    } else {
-      stores.push(new import_keyv.Keyv());
+    } else {
+      stores.push(new import_keyv.Keyv());
+    }
+    return stores;
+  }
+
+  // src/cache/request-cache.ts
+  var RequestCache = class extends Cache {
+    constructor(options) {
+      super({
+        ...options
+      });
+    }
+  };
+
+  // src/cache/resource-cache.ts
+  var import_keyv2 = __require("keyv");
+  var ResourceCache = class extends Cache {
+    constructor(options) {
+      super({
+        stores: buildStores2(),
+        ...options
+      });
+    }
+  };
+  function buildStores2() {
+    return [
+      new import_keyv2.Keyv({
+        // Disabling serialization allows for pure memo-ization of class instances
+        // at the tradeoff of no support for compression.
+        serialize: void 0,
+        deserialize: void 0
+      })
+    ];
+  }
+
+  // src/cache/theme-cache.ts
+  var TTL = 90 * 24 * 60 * 60 * 1e3;
+  var ThemeCache = class extends Cache {
+    constructor(options) {
+      super({
+        ttl: TTL,
+        ...options
+      });
+    }
+  };
+
+  // src/resources/product_helpers.ts
+  function calculateAddOptionsPrice(product, queryParams) {
+    const { option_values = "" } = queryParams;
+    const queryOptionValues = option_values;
+    const optionValues = queryOptionValues.split(",");
+    const addPrice = product.options?.reduce((acc, option) => {
+      if (!option.active || !option.values || option.values.length <= 0) {
+        return acc;
+      }
+      if (option.input_type !== "select") {
+        return acc;
+      }
+      for (const value of option.values) {
+        if (optionValues.includes(value.id)) {
+          return acc + (value.price || 0);
+        }
+      }
+      return acc + (option.values[0].price || 0);
+    }, 0);
+    return product.price + (addPrice || 0);
+  }
+  function calculateAddOptionsVariantPrice(product, variant, queryParams) {
+    const { option_values = "" } = queryParams;
+    const queryOptionValues = option_values;
+    const optionValues = queryOptionValues.split(",");
+    const addPrice = product.options?.reduce((acc, option) => {
+      if (option.variant || // skip variant options
+      !option.active || !option.values || option.values.length <= 0) {
+        return acc;
+      }
+      if (option.input_type !== "select") {
+        return acc;
+      }
+      for (const value of option.values) {
+        if (optionValues.includes(value.id)) {
+          return acc + (value.price || 0);
+        }
+      }
+      return acc + (option.values[0].price || 0);
+    }, 0);
+    let price = product.price;
+    if (variant.price !== null && variant.price !== void 0) {
+      price = variant.price;
+    }
+    return price + (addPrice || 0);
+  }
+  function getAvailableVariants(product) {
+    return (product.variants?.results?.slice()?.reverse() || []).filter(
+      (variant) => variant.stock_status === "in_stock" || !variant.stock_status
+    );
+  }
+  function getSelectedSwellVariant(product, queryParams) {
+    const { variant: queryVariant, option_values } = queryParams;
+    const queryOptionValues = option_values;
+    const variants = getAvailableVariants(product);
+    let selectedVariant = void 0;
+    if (queryVariant) {
+      selectedVariant = variants.find((variant) => variant.id === queryVariant);
+    } else if (queryOptionValues) {
+      const optionValues = queryOptionValues.split(",");
+      selectedVariant = variants.find(
+        (variant) => variant.option_value_ids.every(
+          (optionValueId) => optionValues.includes(optionValueId)
+        )
+      );
     }
-    return stores;
+    return selectedVariant || variants?.[0] || void 0;
   }
-
-  // src/cache/request-cache.ts
-  var RequestCache = class extends Cache {
-    constructor(options) {
-      super({
-        ...options
-      });
+  function getSelectedVariant(product, queryParams) {
+    return getSelectedSwellVariant(
+      product,
+      queryParams
+    );
+  }
+  function getSelectedOptionValues(product, queryParams) {
+    const variant = getSelectedSwellVariant(product, queryParams);
+    return getSelectedVariantOptionValues(product, variant, queryParams);
+  }
+  function getSelectedVariantOptionValues(product, variant, queryParams) {
+    const { option_values = "" } = queryParams;
+    const queryOptionValues = option_values;
+    const optionValues = queryOptionValues.split(",");
+    const selectedValues = variant ? [...variant.option_value_ids || []] : [];
+    const values = [];
+    for (const option of product.options || []) {
+      if (option.active && option.values && option.values.length > 0 && option.input_type === "select") {
+        let selectedByVariantId = "";
+        let selectedByOptionId = "";
+        for (const value of option.values) {
+          if (selectedValues.includes(value.id)) {
+            selectedByVariantId = value.id;
+            break;
+          }
+          if (optionValues.includes(value.id)) {
+            selectedByOptionId = value.id;
+          }
+        }
+        values.push(
+          selectedByVariantId || selectedByOptionId || option.values[0].id
+        );
+      }
     }
-  };
+    return values;
+  }
 
-  // src/cache/resource-cache.ts
-  var import_keyv2 = __require("keyv");
-  var ResourceCache = class extends Cache {
-    constructor(options) {
-      super({
-        stores: buildStores2(),
-        ...options
-      });
+  // src/resources/variant.ts
+  function transformSwellVariant(params, product, variant) {
+    if (!product) {
+      return product;
     }
-  };
-  function buildStores2() {
-    return [
-      new import_keyv2.Keyv({
-        // Disabling serialization allows for pure memo-ization of class instances
-        // at the tradeoff of no support for compression.
-        serialize: void 0,
-        deserialize: void 0
-      })
-    ];
+    if (!variant) {
+      return variant;
+    }
+    return {
+      ...variant,
+      // add swell properties there
+      price: calculateAddOptionsVariantPrice(product, variant, params),
+      selected_option_values: getSelectedVariantOptionValues(
+        product,
+        variant,
+        params
+      )
+    };
   }
 
-  // src/cache/theme-cache.ts
-  var TTL = 90 * 24 * 60 * 60 * 1e3;
-  var ThemeCache = class extends Cache {
-    constructor(options) {
-      super({
-        ttl: TTL,
-        ...options
-      });
+  // src/resources/product.ts
+  function transformSwellProduct(params, product) {
+    if (!product) {
+      return product;
+    }
+    const newProduct = {
+      ...product,
+      // add swell properties there
+      price: calculateAddOptionsPrice(product, params),
+      selected_option_values: getSelectedOptionValues(product, params)
+    };
+    if (Array.isArray(newProduct.variants?.results)) {
+      newProduct.variants = {
+        ...newProduct.variants,
+        results: newProduct.variants.results.map(
+          (variant) => transformSwellVariant(params, product, variant)
+        )
+      };
+    }
+    return newProduct;
+  }
+  var SwellProduct = class extends SwellStorefrontRecord {
+    _params;
+    constructor(swell, id, query = {}, getter) {
+      super(swell, "products", id, query, getter);
+      this._params = swell.queryParams;
+      return this._getProxy();
+    }
+    // add swell properties to the resolved object
+    _transformResult(result) {
+      const res = transformSwellProduct(
+        this._params,
+        result
+      );
+      return res;
     }
   };
 
@@ -7494,39 +7677,6 @@ ${formattedMessage}`;
     }
   };
 
-  // src/products.ts
-  function getProducts(swell, query) {
-    return new SwellStorefrontCollection(swell, "products", query);
-  }
-  function getProduct(swell, id, query) {
-    return new SwellStorefrontRecord(swell, "products", id, query);
-  }
-  function getProductsFiltered(swell, {
-    search,
-    filter,
-    sort
-  }) {
-    return new SwellStorefrontCollection(swell, "products", {
-      search,
-      filter,
-      sort
-    });
-  }
-
-  // src/categories.ts
-  function getCategories(swell, query) {
-    return new SwellStorefrontCollection(swell, "categories", query);
-  }
-  function getCategory(swell, id, query) {
-    return new SwellStorefrontRecord(swell, "categories", id, query);
-  }
-  async function getCategoryWithProducts(swell, id, query) {
-    const category = getCategory(swell, id, query);
-    const categoryId = await category.id;
-    category.products = getProducts(swell, { category: categoryId });
-    return category;
-  }
-
   // src/content.ts
   function getContentModel(swell, name) {
     return swell.getCachedResource(
@@ -13637,6 +13787,9 @@ ${formattedMessage}`;
       "moderated?": false
     });
   }
+  function isLikeShopifyArticle(value) {
+    return typeof value === "object" && value !== null && Object.hasOwn(value, "title") && Object.hasOwn(value, "content") && Object.hasOwn(value, "comments") && Object.hasOwn(value, "moderated?") && Object.hasOwn(value, "published_at") && Object.hasOwn(value, "excerpt_or_content");
+  }
 
   // src/compatibility/shopify-objects/blog.ts
   function ShopifyBlog(instance, blogCategory) {
@@ -13716,11 +13869,15 @@ ${formattedMessage}`;
     if (variant instanceof ShopifyResource) {
       return variant.clone();
     }
+    let swellVariant = {};
     if (variant instanceof StorefrontResource) {
       variant = cloneStorefrontResource(variant);
+    } else {
+      swellVariant = { ...variant };
     }
     const product = productIn || variant.product || {};
     return new ShopifyResource({
+      ...swellVariant,
       available: deferWith(
         variant,
         (variant2) => Boolean(variant2.stock_status === "in_stock" || !variant2.stock_status)
@@ -13766,25 +13923,19 @@ ${formattedMessage}`;
       metafields: {},
       next_incoming_date: void 0,
       options: getOptions(product, variant),
-      // @ts-expect-error: move this to swell product class
-      selected_option_values: deferWith(
-        [product, variant],
-        (product2, variant2) => getSelectedVariantOptionValues(
-          product2,
-          variant2,
-          instance.swell.queryParams
-        )
-      ),
       option1: getOptionByIndex(product, variant, 0),
       // Deprecated by Shopify
       option2: getOptionByIndex(product, variant, 1),
       // Deprecated by Shopify
       option3: getOptionByIndex(product, variant, 2),
       // Deprecated by Shopify
-      price: deferWith(
-        [product, variant],
-        (product2, variant2) => getVariantPrice(product2, variant2, instance.swell.queryParams)
-      ),
+      price: deferWith([product, variant], (product2, variant2) => {
+        let price = product2.price;
+        if (variant2.price !== null && variant2.price !== void 0) {
+          price = variant2.price;
+        }
+        return price;
+      }),
       product: deferWith(product, (product2) => {
         return ShopifyProduct(
           instance,
@@ -13871,30 +14022,6 @@ ${formattedMessage}`;
       }
     );
   }
-  function getVariantPrice(product, variant, queryParams) {
-    const { option_values: queryOptionValues = "" } = queryParams;
-    const optionValues = queryOptionValues.split(",");
-    const addPrice = product.options?.reduce((acc, option) => {
-      if (option.variant || // skip variant options
-      !option.active || !option.values || option.values.length <= 0) {
-        return acc;
-      }
-      if (option.input_type !== "select") {
-        return acc;
-      }
-      for (const value of option.values) {
-        if (optionValues.includes(value.id)) {
-          return acc + (value.price || 0);
-        }
-      }
-      return acc + (option.values[0].price || 0);
-    }, 0);
-    let price = product.price;
-    if (variant.price !== null && variant.price !== void 0) {
-      price = variant.price;
-    }
-    return price + (addPrice || 0);
-  }
 
   // src/compatibility/shopify-objects/product.ts
   function ShopifyProduct(instance, product, depth = 0) {
@@ -13934,7 +14061,7 @@ ${formattedMessage}`;
       // not used
       first_available_variant: deferWith(product, (product2) => {
         const variant = getSelectedVariant(product2, {});
-        return ShopifyVariant(instance, variant || product2, product2, depth + 1);
+        return variant ? ShopifyVariant(instance, variant, product2, depth + 1) : void 0;
       }),
       "gift_card?": deferWith(product, (product2) => product2.type === "giftcard"),
       handle: defer(() => product.slug),
@@ -13970,12 +14097,6 @@ ${formattedMessage}`;
         }
         return product2.options.filter((option) => option.active && option.name).map((option) => option.name);
       }),
-      // all options values including non-variant
-      // @ts-expect-error: move this to swell product class
-      selected_option_values: deferWith(
-        product,
-        (product2) => getSelectedOptionValues(product2, instance.swell.queryParams)
-      ),
       options_by_name: deferWith(product, (product2) => {
         if (!Array.isArray(product2.options)) {
           return {};
@@ -14043,30 +14164,33 @@ ${formattedMessage}`;
           });
         }
       ),
-      price: deferWith(
-        product,
-        (product2) => calculateAddOptionsPrice(product2, instance.swell.queryParams)
-      ),
-      price_max: deferWith(
-        product,
-        (product2) => product2.variants?.results?.reduce(
+      price: deferWith(product, (product2) => product2.price),
+      price_max: deferWith(product, (product2) => {
+        if (!Array.isArray(product2.variants?.results)) {
+          return product2.price;
+        }
+        return product2.variants.results.reduce(
           (max, variant) => Math.max(max, variant.price),
           0
-        )
-      ),
-      price_min: deferWith(
-        product,
-        (product2) => product2.variants?.results?.reduce(
+        );
+      }),
+      price_min: deferWith(product, (product2) => {
+        if (!Array.isArray(product2.variants?.results)) {
+          return product2.price;
+        }
+        return product2.variants.results.reduce(
           (min, variant) => Math.min(min, variant.price),
           Infinity
-        )
-      ),
-      price_varies: deferWith(
-        product,
-        (product2) => product2.variants?.results?.some(
+        );
+      }),
+      price_varies: deferWith(product, (product2) => {
+        if (!Array.isArray(product2.variants?.results)) {
+          return false;
+        }
+        return product2.variants.results.some(
           (variant) => variant.price !== product2.price
-        )
-      ),
+        );
+      }),
       published_at: deferWith(
         product,
         (product2) => product2.date_updated || product2.date_created
@@ -14075,6 +14199,8 @@ ${formattedMessage}`;
         product,
         (product2) => product2.prices?.length > 0
       ),
+      // ShopifyProduct does not have this property
+      // @ts-expect-error property
       quantity_rule: deferWith(product, (product2) => {
         let inventory = product2.stock_level || 0;
         if (inventory < 0) {
@@ -14102,11 +14228,8 @@ ${formattedMessage}`;
       selected_or_first_available_variant: deferWith(
         product,
         (product2) => {
-          let variant = getSelectedVariant(product2, instance.swell.queryParams);
-          if (!variant) {
-            variant = product2;
-          }
-          return ShopifyVariant(instance, variant, product2, depth + 1);
+          const variant = getSelectedVariant(product2, instance.swell.queryParams);
+          return variant ? ShopifyVariant(instance, variant, product2, depth + 1) : void 0;
         }
       ),
       selected_selling_plan: void 0,
@@ -14127,82 +14250,17 @@ ${formattedMessage}`;
         ).reverse();
         return variants;
       }),
+      variants_count: deferWith(product, (product2) => {
+        return product2.variants?.count || 0;
+      }),
       vendor: void 0
     });
   }
   function ShopifyProductOptionValue(values) {
     return new ShopifyResource(values, "name");
   }
-  function getSelectedVariant(product, queryParams) {
-    const { variant: queryVariant, option_values: queryOptionValues } = queryParams;
-    const variants = getAvailableVariants(product);
-    let selectedVariant = void 0;
-    if (queryVariant) {
-      selectedVariant = variants.find(
-        (variant) => variant.id === queryVariant
-      );
-    } else if (queryOptionValues) {
-      const optionValues = queryOptionValues.split(",");
-      selectedVariant = variants.find(
-        (variant) => variant.option_value_ids.every(
-          (optionValueId) => optionValues.includes(optionValueId)
-        )
-      );
-    }
-    return selectedVariant || variants?.[0] || void 0;
-  }
-  function getAvailableVariants(product) {
-    return (product.variants?.results?.slice()?.reverse() || []).filter(
-      (variant) => variant.stock_status === "in_stock" || !variant.stock_status
-    );
-  }
-  function calculateAddOptionsPrice(product, queryParams) {
-    const { option_values: queryOptionValues = "" } = queryParams;
-    const optionValues = queryOptionValues.split(",");
-    const addPrice = product.options?.reduce((acc, option) => {
-      if (!option.active || !option.values || option.values.length <= 0) {
-        return acc;
-      }
-      if (option.input_type !== "select") {
-        return acc;
-      }
-      for (const value of option.values) {
-        if (optionValues.includes(value.id)) {
-          return acc + (value.price || 0);
-        }
-      }
-      return acc + (option.values[0].price || 0);
-    }, 0);
-    return product.price + (addPrice || 0);
-  }
-  function getSelectedOptionValues(product, queryParams) {
-    const variant = getSelectedVariant(product, queryParams);
-    return getSelectedVariantOptionValues(product, variant, queryParams);
-  }
-  function getSelectedVariantOptionValues(product, variant, queryParams) {
-    const { option_values: queryOptionValues = "" } = queryParams;
-    const optionValues = queryOptionValues.split(",");
-    const selectedValues = variant ? [...variant.option_value_ids || []] : [];
-    const values = [];
-    for (const option of product.options || []) {
-      if (option.active && option.values?.length > 0 && option.input_type === "select") {
-        let selectedByVariantId = "";
-        let selectedByOptionId = "";
-        for (const value of option.values) {
-          if (selectedValues.includes(value.id)) {
-            selectedByVariantId = value.id;
-            break;
-          }
-          if (optionValues.includes(value.id)) {
-            selectedByOptionId = value.id;
-          }
-        }
-        values.push(
-          selectedByVariantId || selectedByOptionId || option.values[0].id
-        );
-      }
-    }
-    return values;
+  function isLikeShopifyProduct(value) {
+    return typeof value === "object" && value !== null && Object.hasOwn(value, "variants") && Object.hasOwn(value, "gift_card?") && Object.hasOwn(value, "price_varies") && Object.hasOwn(value, "has_only_default_variant");
   }
 
   // src/compatibility/shopify-objects/line_item.ts
@@ -17272,7 +17330,7 @@ ${injects.join("\n")}<\/script>`;
   };
   function bindTags(liquidSwell) {
     Object.entries(tags).forEach(
-      ([tag, bind61]) => liquidSwell.registerTag(tag, bind61(liquidSwell))
+      ([tag, bind62]) => liquidSwell.registerTag(tag, bind62(liquidSwell))
     );
   }
 
@@ -18094,8 +18152,86 @@ ${injects.join("\n")}<\/script>`;
     };
   }
 
-  // src/liquid/filters/inline_editable.ts
+  // src/liquid/filters/shopify/structured_data.ts
   function bind60(_liquidSwell) {
+    return async function filterStructuredData(input) {
+      let value = input;
+      if (value instanceof StorefrontResource) {
+        value = await value.resolve();
+      }
+      await resolveAllKeys(value);
+      if (isObject2(value)) {
+        if (isLikeShopifyProduct(value)) {
+          return JSON.stringify(
+            value.variants_count > 0 ? convertToSchemaOrgProductGroup(value) : convertToSchemaOrgProduct(
+              value,
+              value
+            )
+          );
+        }
+        if (isLikeShopifyArticle(value)) {
+          return JSON.stringify(convertToSchemaOrgArticle(value));
+        }
+      }
+      return value;
+    };
+  }
+  function convertToSchemaOrgArticle(article) {
+    const schemaOrgArticle = {
+      "@context": "https://schema.org",
+      "@type": "Article",
+      "@id": article.url,
+      url: article.url,
+      name: article.title,
+      author: article.author,
+      image: article.image?.src.url || void 0,
+      abstract: article.excerpt,
+      keywords: article.tags,
+      articleBody: article.content,
+      dateCreated: article.created_at,
+      dateModified: article.updated_at,
+      datePublished: article.published_at
+    };
+    return schemaOrgArticle;
+  }
+  function convertToSchemaOrgProduct(variant, product) {
+    const schemaOrgProduct = {
+      "@context": "https://schema.org",
+      "@type": "Product",
+      "@id": variant.url,
+      url: variant.url,
+      sku: variant.sku,
+      name: variant.title,
+      image: variant.featured_image?.src.url || void 0,
+      keywords: product.tags,
+      description: product.description,
+      offers: {
+        "@type": "Offer",
+        availability: variant.available ? "https://schema.org/InStock" : "https://schema.org/OutOfStock",
+        price: variant.price,
+        priceCurrency: "USD"
+      }
+    };
+    return schemaOrgProduct;
+  }
+  function convertToSchemaOrgProductGroup(product) {
+    const schemaOrgProductGroup = {
+      "@context": "https://schema.org",
+      "@type": "ProductGroup",
+      productGroupID: String(product.id),
+      url: product.url,
+      name: product.title,
+      description: product.description,
+      variesBy: product.options,
+      hasVariant: product.variants.map(
+        (variant) => convertToSchemaOrgProduct(variant, product)
+      )
+    };
+    return schemaOrgProductGroup;
+  }
+
+  // src/liquid/filters/inline_editable.ts
+  function bind61(_liquidSwell) {
     return (value, key) => {
       if (typeof value === "object" && "value" in value) {
         value = value.value;
@@ -18154,8 +18290,9 @@ ${injects.join("\n")}<\/script>`;
     payment_terms: bind57,
     placeholder_svg_tag: bind58,
     shopify_asset_url: bind59,
+    structured_data: bind60,
     // Swell only
-    inline_editable: bind60
+    inline_editable: bind61
   };
   function bindFilters(liquidSwell) {
     for (const [tag, handler] of Object.entries(filters)) {
@@ -18169,8 +18306,8 @@ ${injects.join("\n")}<\/script>`;
       }
     }
   }
-  function bindWithResolvedProps(liquidSwell, bind61, resolve = []) {
-    const handler = bind61(liquidSwell);
+  function bindWithResolvedProps(liquidSwell, bind62, resolve = []) {
+    const handler = bind62(liquidSwell);
     if (!Array.isArray(resolve)) {
       return handler;
     }