@swell/apps-sdk 1.0.150 → 1.0.151

package/dist/index.mjs

@@ -626,18 +626,12 @@ var StorefrontResource = class {
     }
     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 ?? null;
         if (result) {
           Object.assign(this, result);
@@ -720,7 +714,6 @@ function cloneStorefrontResource(input) {
   });
   const clone = new ClonedClass(input._getter);
   clone._params = input._params;
-  clone._transformResult = input._transformResult.bind(clone);
   Object.defineProperty(clone, "_resourceName", {
     value: resourceName
   });
@@ -774,7 +767,11 @@ var SwellStorefrontCollection = class _SwellStorefrontCollection extends SwellSt
   limit = DEFAULT_QUERY_PAGE_LIMIT;
   name;
   constructor(swell, collection, query = {}, getter) {
-    super(swell, collection, getter);
+    super(
+      swell,
+      collection,
+      getter
+    );
     this._query = this._initQuery(query);
     if (!getter) {
       this._setGetter(this._defaultGetter());
@@ -950,8 +947,6 @@ var SwellStorefrontRecord = class extends SwellStorefrontResource {
         getter,
         isResourceCacheble(this._collection)
       ).then((result) => {
-        return this._transformResult(result);
-      }).then((result) => {
         this._result = result;
         if (result) {
           Object.assign(this, result);
@@ -7708,59 +7703,146 @@ var WorkerCacheProxy = class {
   }
 };
 
+// src/resources/addresses.ts
+var SwellAddresses = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    const { page, limit: limit2 } = swell.queryParams;
+    super(swell, "accounts:addresses", { page, limit: limit2, ...query }, function() {
+      return this._swell.storefront.account.listAddresses(
+        this._query
+      );
+    });
+  }
+};
+
+// src/resources/orders.ts
+var SwellOrders = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    const { page, limit: limit2 } = swell.queryParams;
+    super(swell, "accounts:orders", { page, limit: limit2, ...query }, function() {
+      return this._swell.storefront.account.listOrders(this._query);
+    });
+  }
+};
+
+// src/resources/subscriptions.ts
+var SwellSubscriptions = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    const { page, limit: limit2 } = swell.queryParams;
+    super(
+      swell,
+      "accounts:subscriptions",
+      { page, limit: limit2, ...query },
+      function() {
+        return this._swell.storefront.subscriptions.list(
+          this._query
+        );
+      }
+    );
+  }
+};
+
 // src/resources/account.ts
 var SwellAccount = class extends SwellStorefrontSingleton {
-  constructor(swell, getter) {
-    super(swell, "account", getter);
+  constructor(swell) {
+    super(swell, "account", async function() {
+      const account = await this._defaultGetter().call(this);
+      if (!account) {
+        return null;
+      }
+      account.addresses = new SwellAddresses(
+        this._swell
+      );
+      account.orders = new SwellOrders(
+        this._swell
+      );
+      account.subscriptions = new SwellSubscriptions(
+        this._swell
+      );
+      return account;
+    });
     return this._getProxy();
   }
 };
 
 // src/resources/blog_category.ts
 var SwellBlogCategory = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "content/blog-categories", id, query, getter);
+  constructor(swell, id, query) {
+    super(swell, "content/blog-categories", id, query, async function() {
+      const category = await this._defaultGetter().call(this);
+      if (!category) {
+        return null;
+      }
+      category.blogs = new SwellStorefrontCollection(
+        this._swell,
+        "content/blogs",
+        {
+          category_id: category.id,
+          expand: "author"
+        }
+      );
+      return category;
+    });
     return this._getProxy();
   }
 };
 
 // src/resources/blog.ts
 var SwellBlog = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "content/blogs", id, query, getter);
+  constructor(swell, blogId, categoryId, query) {
+    super(swell, "content/blogs", blogId, query, async function() {
+      this._query = { ...this._query, expand: "author" };
+      const blog = await this._defaultGetter().call(this);
+      if (!blog) {
+        return null;
+      }
+      if (categoryId) {
+        blog.category = new SwellStorefrontRecord(
+          this._swell,
+          "content/blog-categories",
+          categoryId
+        );
+      }
+      return blog;
+    });
     return this._getProxy();
   }
 };
 
 // src/resources/cart.ts
 var SwellCart = class extends SwellStorefrontSingleton {
-  constructor(swell, getter) {
-    super(swell, "cart", getter);
-    return this._getProxy();
-  }
-};
-
-// src/resources/category.ts
-var SwellCategory = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "categories", id, query, getter);
-    return this._getProxy();
-  }
-};
-
-// src/resources/order.ts
-var SwellOrder = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "orders", id, query, getter);
+  constructor(swell) {
+    super(swell, "cart");
     return this._getProxy();
   }
 };
 
-// src/resources/page.ts
-var SwellPage = class extends SwellStorefrontRecord {
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "content/pages", id, query, getter);
-    return this._getProxy();
+// src/resources/categories.ts
+var SwellCategories = class extends SwellStorefrontCollection {
+  constructor(swell, query) {
+    super(
+      swell,
+      "categories",
+      {
+        limit: 100,
+        top_id: null,
+        ...query
+      },
+      async function() {
+        const categories = await this._defaultGetter().call(this);
+        if (!categories) {
+          return null;
+        }
+        for (const category of categories.results) {
+          category.products = new SwellStorefrontCollection(
+            this._swell,
+            "products",
+            { category: category.id }
+          );
+        }
+        return categories;
+      }
+    );
   }
 };
 
@@ -7920,6 +8002,143 @@ function getSelectedSubscriptionPurchaseOptionPlan(selectedPurchaseOptionType, s
   }
   return selectedPlan || subscriptionPurchaseOption.plans[0];
 }
+var SORT_OPTIONS = Object.freeze([
+  { value: "", name: "Featured" },
+  { value: "popularity", name: "Popularity", query: "popularity desc" },
+  { value: "price_asc", name: "Price, low to high", query: "price asc" },
+  { value: "price_desc", name: "Price, high to low", query: "price desc" },
+  { value: "date_asc", name: "Date, old to new", query: "date asc" },
+  { value: "date_desc", name: "Date, new to old", query: "date desc" },
+  { value: "name_asc", name: "Product name, A-Z", query: "name asc" },
+  { value: "name_desc", name: "Product name, Z-A", query: "name desc" }
+]);
+async function getProductFilters(swell, productQuery) {
+  const sortBy = swell.queryParams.sort || "";
+  const filterQuery = productQueryWithFilters(swell, productQuery);
+  return {
+    filter_options: await getProductFiltersByQuery(swell, filterQuery),
+    sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.value,
+    sort_options: [...SORT_OPTIONS]
+  };
+}
+async function getProductFiltersByQuery(swell, query = {}) {
+  const filters2 = await swell.get("/products/:filters", {
+    ...query,
+    sort: void 0
+  }) || [];
+  if (!Array.isArray(filters2)) {
+    throw new Error("Product filters must be an array");
+  }
+  for (const filter of filters2) {
+    filter.param_name = `filter_${filter.id}`;
+    if (Array.isArray(filter.options)) {
+      filter.active_options = [];
+      filter.inactive_options = [];
+      for (const option of filter.options) {
+        const queryValue = swell.queryParams[filter.param_name];
+        option.active = Array.isArray(queryValue) ? queryValue.includes(option.value) : queryValue === option.value;
+        const list = option.active ? filter.active_options : filter.inactive_options;
+        list.push(option);
+      }
+    }
+  }
+  return filters2;
+}
+function productQueryWithFilters(swell, query) {
+  const filters2 = Object.keys(swell.queryParams).reduce(
+    (acc, key) => {
+      if (key.startsWith("filter_")) {
+        const qkey = key.replace("filter_", "");
+        const value = swell.queryParams[key];
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && (value.gte !== void 0 || value.lte !== void 0)) {
+          acc[qkey] = [value.gte || 0, value.lte || void 0];
+        } else {
+          acc[qkey] = value;
+        }
+      }
+      return acc;
+    },
+    {}
+  );
+  const sortBy = swell.queryParams.sort || "";
+  return {
+    sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.query || void 0,
+    $filters: filters2,
+    ...query
+  };
+}
+
+// src/resources/category.ts
+var SwellCategory = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "categories", id, query, async function() {
+      let category = await this._defaultGetter().call(this);
+      if (!category && this._id === "all") {
+        category = {
+          name: "Products",
+          id: "all",
+          slug: "all",
+          filter_options: [],
+          sort_options: []
+        };
+      }
+      if (!category) {
+        return null;
+      }
+      const productFilters = await getProductFilters(
+        this._swell,
+        category.id !== "all" ? { category: category.id, $variants: true } : { $variants: true }
+      );
+      Object.assign(category, productFilters);
+      return category;
+    });
+    return this._getProxy();
+  }
+};
+
+// src/resources/order.ts
+var SwellOrder = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "accounts:orders", id, query, function() {
+      return this._swell.storefront.account.getOrder(this._id);
+    });
+    return this._getProxy();
+  }
+};
+
+// src/resources/page.ts
+var SwellPage = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "content/pages", id, query);
+    return this._getProxy();
+  }
+};
+
+// src/resources/predictive_search.ts
+var SwellPredictiveSearch = class extends StorefrontResource {
+  constructor(swell, query) {
+    super(async function() {
+      const performed = String(query || "").length > 0;
+      let products;
+      if (performed) {
+        products = new SwellStorefrontCollection(
+          swell,
+          "products",
+          {
+            search: query,
+            limit: 10
+          }
+        );
+        await products.resolve();
+      }
+      return {
+        query,
+        performed,
+        products
+      };
+    });
+  }
+};
 
 // src/resources/variant.ts
 function transformSwellVariant(params, product, variant) {
@@ -7939,27 +8158,30 @@ function transformSwellVariant(params, product, variant) {
     )
   };
 }
+var SwellVariant = class extends SwellStorefrontRecord {
+  product;
+  constructor(swell, product, id, query) {
+    super(swell, "products:variants", id, query, async function() {
+      const variant = await this._swell.get(
+        "/products:variants/{id}",
+        { id: this._id }
+      );
+      return variant ?? null;
+    });
+    this.product = product;
+  }
+};
 
 // src/resources/product.ts
-var SORT_OPTIONS = [
-  { value: "", name: "Featured" },
-  { value: "popularity", name: "Popularity", query: "popularity desc" },
-  { value: "price_asc", name: "Price, low to high", query: "price asc" },
-  { value: "price_desc", name: "Price, high to low", query: "price desc" },
-  { value: "date_asc", name: "Date, old to new", query: "date asc" },
-  { value: "date_desc", name: "Date, new to old", query: "date desc" },
-  { value: "name_asc", name: "Product name, A-Z", query: "name asc" },
-  { value: "name_desc", name: "Product name, Z-A", query: "name desc" }
-];
 function transformSwellProduct(params, product) {
   if (!product) {
-    return product;
+    return null;
   }
   const newProduct = {
     ...product,
     // add swell properties there
     selected_option_values: getSelectedVariantOptionValues(product, params),
-    purchase_options: getPurchaseOptions(product, params)
+    purchase_options: getPurchaseOptions(product, params) ?? void 0
   };
   if (Array.isArray(newProduct.variants?.results)) {
     newProduct.variants = {
@@ -7972,43 +8194,49 @@ function transformSwellProduct(params, product) {
   return newProduct;
 }
 var SwellProduct = class extends SwellStorefrontRecord {
-  _params;
-  constructor(swell, id, query = {}, getter) {
-    super(swell, "products", id, query, getter);
-    this._params = swell.queryParams;
+  constructor(swell, id, query) {
+    const params = swell.queryParams;
+    super(swell, "products", id, query, async function() {
+      const result = await this._defaultGetter().call(this);
+      return transformSwellProduct(params, result);
+    });
     return this._getProxy();
   }
-  // add swell properties to the resolved object
-  _transformResult(result) {
-    const res = transformSwellProduct(
-      this._params,
-      result
-    );
-    return res;
+};
+
+// src/resources/product_recommendations.ts
+var SwellProductRecommendations = class extends SwellProduct {
+  constructor(swell, id, query) {
+    super(swell, id, { ...query, $recommendations: true });
+  }
+};
+
+// src/resources/search.ts
+var SwellSearch = class extends StorefrontResource {
+  constructor(swell, query) {
+    super(async () => {
+      const performed = String(query || "").length > 0;
+      const productFilters = await getProductFilters(
+        swell,
+        performed ? { search: query } : void 0
+      );
+      return {
+        query,
+        performed,
+        ...productFilters
+      };
+    });
+  }
+};
+
+// src/resources/subscription.ts
+var SwellSubscription = class extends SwellStorefrontRecord {
+  constructor(swell, id, query) {
+    super(swell, "accounts:subscriptions", id, query, function() {
+      return this._swell.storefront.subscriptions.get(this._id, this._query);
+    });
   }
 };
-function productQueryWithFilters(swell, query = {}) {
-  const sortBy = swell.queryParams.sort || "";
-  const filters2 = Object.entries(swell.queryParams).reduce(
-    (acc, [key, value]) => {
-      if (key.startsWith("filter_")) {
-        const qkey = key.replace("filter_", "");
-        if (value?.gte !== void 0 || value?.lte !== void 0) {
-          acc[qkey] = [value.gte || 0, value.lte || void 0];
-        } else {
-          acc[qkey] = value;
-        }
-      }
-      return acc;
-    },
-    {}
-  );
-  return {
-    sort: SORT_OPTIONS.find((option) => option.value === sortBy)?.query || void 0,
-    $filters: filters2,
-    ...query
-  };
-}
 
 // src/api.ts
 var DEFAULT_API_HOST = "https://api.schema.io";
@@ -15579,11 +15807,9 @@ function getProducts(instance, object, mapper) {
         return this._defaultGetter().call(this);
       }
     );
-    return products._cloneWithCompatibilityResult(
-      (products2) => {
-        return { ...products2, results: products2.results.map(mapper) };
-      }
-    );
+    return products._cloneWithCompatibilityResult((products2) => {
+      return { ...products2, results: products2.results.map(mapper) };
+    });
   });
 }
 function makeProductsCollectionResolve(instance, object, mapper) {
@@ -15600,19 +15826,24 @@ function makeProductsCollectionResolve(instance, object, mapper) {
 
 // src/compatibility/shopify-objects/collections.ts
 function ShopifyCollections(instance, categories) {
-  return new SwellStorefrontCollection(instance.swell, categories._collection, categories._query, async () => {
-    const results = (await categories.results)?.map((category) => {
-      return ShopifyCollection(instance, category);
-    });
-    return {
-      page: categories.page ?? 1,
-      count: categories.count ?? 0,
-      results: results ?? [],
-      page_count: categories.page_count ?? 0,
-      limit: categories.limit,
-      pages: categories.pages ?? {}
-    };
-  });
+  return new SwellStorefrontCollection(
+    instance.swell,
+    categories._collection,
+    categories._query,
+    async () => {
+      const results = (await categories.results)?.map((category) => {
+        return ShopifyCollection(instance, category);
+      });
+      return {
+        page: categories.page ?? 1,
+        count: categories.count ?? 0,
+        results: results ?? [],
+        page_count: categories.page_count ?? 0,
+        limit: categories.limit,
+        pages: categories.pages ?? {}
+      };
+    }
+  );
 }
 
 // src/compatibility/shopify-objects/address.ts
@@ -16799,13 +17030,12 @@ var ImagesDrop = class extends Drop7 {
 var SwellImage = class extends StorefrontResource {
   constructor(swell, name) {
     super(async () => {
-      const files = await swell.get("/:files", {
+      const file = await swell.get("/:files/:last", {
         private: { $ne: true },
         content_type: { $regex: "^image/" },
         filename: name
       });
-      const file = files?.results[0] ?? null;
-      if (file === null) {
+      if (!file) {
         return null;
       }
       return { file };
@@ -22107,21 +22337,30 @@ export {
   StorefrontResource,
   Swell,
   SwellAccount,
+  SwellAddresses,
   SwellBackendAPI,
   SwellBlog,
   SwellBlogCategory,
   SwellCart,
+  SwellCategories,
   SwellCategory,
   SwellError,
   SwellOrder,
+  SwellOrders,
   SwellPage,
+  SwellPredictiveSearch,
   SwellProduct,
+  SwellProductRecommendations,
+  SwellSearch,
   SwellStorefrontCollection,
   SwellStorefrontPagination,
   SwellStorefrontRecord,
   SwellStorefrontResource,
   SwellStorefrontSingleton,
+  SwellSubscription,
+  SwellSubscriptions,
   SwellTheme3 as SwellTheme,
+  SwellVariant,
   ThemeColor,
   ThemeFont,
   ThemeForm,