@moonbase.sh/vue 0.2.115 → 0.2.117

package/dist/index.cjs

@@ -139,6 +139,7 @@ var _StorefrontContextImpl = class _StorefrontContextImpl {
     this.stateFactory = stateFactory;
     this.currentUser = (0, import_vue.ref)(null);
     this.loadedUser = (0, import_vue.ref)(false);
+    this.refreshOrderAbortController = new AbortController();
     this.debouncedPushOrderContent = debounce((order) => this.client.orders.pushContent(order, void 0, this.hasUtm ? this.utm.value : void 0), 500);
     var _a;
     if (typeof window === "undefined") {
@@ -287,6 +288,8 @@ var _StorefrontContextImpl = class _StorefrontContextImpl {
   async pushOrderContent() {
     if (typeof window !== "undefined")
       localStorage.setItem(_StorefrontContextImpl.sessionKey, JSON.stringify(this.currentOrder.value));
+    this.refreshOrderAbortController.abort();
+    this.refreshOrderAbortController = new AbortController();
     this.debouncedPushOrderContent(this.currentOrder.value);
   }
   handleStorageUpdate(event) {
@@ -315,7 +318,7 @@ var _StorefrontContextImpl = class _StorefrontContextImpl {
   }
   async refreshOrder() {
     try {
-      const latestOrder = await this.client.orders.get(this.currentOrder.value.id);
+      const latestOrder = await this.client.orders.get(this.currentOrder.value.id, this.refreshOrderAbortController.signal);
       if (latestOrder) {
         if (latestOrder.status !== import_storefront_api2.OrderStatus.Open) {
           this.resetOrder();
@@ -326,7 +329,7 @@ var _StorefrontContextImpl = class _StorefrontContextImpl {
         }
       }
     } catch (err) {
-      if (err != null)
+      if (err instanceof import_storefront_api2.NotAuthorizedError)
         this.resetOrder();
     }
   }
@@ -359,97 +362,19 @@ _StorefrontContextImpl.storefrontKey = "moonbase_storefront";
 _StorefrontContextImpl.utmKey = "moonbase_utm";
 var StorefrontContextImpl = _StorefrontContextImpl;
 
-// src/index.ts
-__reExport(src_exports, require("@moonbase.sh/storefront-api"), module.exports);
-
-// src/composables/useBundle.ts
-var import_vue2 = require("vue");
-function useBundle(bundleId, context) {
-  const storefront = context != null ? context : (0, import_vue2.inject)(storefrontKey);
-  if (!storefront)
-    throw new Error("No storefront configured");
-  return (0, import_vue2.computed)(() => storefront.storefront.value.bundles.find((b) => b.id === bundleId) || null);
-}
-
-// src/composables/useBundles.ts
-var import_vue3 = require("vue");
-function useBundles(context) {
-  const storefront = context != null ? context : (0, import_vue3.inject)(storefrontKey);
-  if (!storefront)
-    throw new Error("No storefront configured");
-  return (0, import_vue3.computed)(() => storefront.storefront.value.bundles);
-}
-
-// src/composables/useProduct.ts
-var import_vue4 = require("vue");
-function useProduct(productId, context) {
-  const storefront = context != null ? context : (0, import_vue4.inject)(storefrontKey);
-  if (!storefront)
-    throw new Error("No storefront configured");
-  return (0, import_vue4.computed)(() => storefront.storefront.value.products.find((p) => p.id === productId) || null);
-}
-
-// src/composables/useProducts.ts
-var import_vue5 = require("vue");
-function useProducts(context) {
-  const storefront = context != null ? context : (0, import_vue5.inject)(storefrontKey);
-  if (!storefront)
-    throw new Error("No storefront configured");
-  return (0, import_vue5.computed)(() => storefront.storefront.value.products);
-}
-
-// src/composables/useInventory.ts
-var import_vue6 = require("vue");
-function useInventory(context) {
-  const storefront = context != null ? context : (0, import_vue6.inject)(storefrontKey);
-  if (!storefront)
-    throw new Error("No storefront configured");
-  return {
-    getLicenses: async (nextUrl) => {
-      return storefront.client.inventory.licenses.get(nextUrl);
-    },
-    getLicenseActivations: async (licenseId, nextUrl) => {
-      return storefront.client.inventory.licenses.getActivations(licenseId, nextUrl);
-    },
-    getProduct: async (productId, version) => {
-      return storefront.client.inventory.products.get(productId, version);
-    },
-    getProducts: async (nextUrl) => {
-      return storefront.client.inventory.products.getOwned(nextUrl);
-    },
-    getProductLicenses: async (productId, nextUrl) => {
-      return storefront.client.inventory.products.getLicenses(productId, nextUrl);
-    },
-    getProductActivations: async (productId, nextUrl) => {
-      return storefront.client.inventory.products.getActivations(productId, nextUrl);
-    },
-    revokeActivation: async (activation) => {
-      return storefront.client.inventory.licenses.revokeActivation(activation.licenseId, activation.id);
-    },
-    activateProduct: async (deviceToken, activationMethod) => {
-      return storefront.client.inventory.activation.activate(deviceToken, activationMethod);
-    },
-    downloadProduct: async (download) => {
-      if (!download.path)
-        throw new Error("Product is not downloadable");
-      window.location.href = await storefront.client.inventory.products.getDownloadUrl(download.path);
-    }
-  };
-}
-
 // src/composables/useActivationRequest.ts
 var import_storefront_api3 = require("@moonbase.sh/storefront-api");
-var import_vue7 = require("vue");
+var import_vue2 = require("vue");
 function useActivationRequest(token, context) {
-  const storefront = context != null ? context : (0, import_vue7.inject)(storefrontKey);
+  const storefront = context != null ? context : (0, import_vue2.inject)(storefrontKey);
   if (!storefront)
     throw new Error("No storefront configured");
-  const activationRequest = storefront.stateFactory(`activation-request-${(0, import_vue7.toValue)(token)}`, null);
-  const error = storefront.stateFactory(`activation-request-${(0, import_vue7.toValue)(token)}-error`, null);
-  const loading = storefront.stateFactory(`activation-request-${(0, import_vue7.toValue)(token)}-loading`, true);
-  const fulfilling = storefront.stateFactory(`activation-request-${(0, import_vue7.toValue)(token)}-fulfilling`, false);
-  const completing = storefront.stateFactory(`activation-request-${(0, import_vue7.toValue)(token)}-completing`, false);
-  const completionTimeout = storefront.stateFactory(`activation-request-${(0, import_vue7.toValue)(token)}-completion-timeout`, null);
+  const activationRequest = storefront.stateFactory(`activation-request-${(0, import_vue2.toValue)(token)}`, null);
+  const error = storefront.stateFactory(`activation-request-${(0, import_vue2.toValue)(token)}-error`, null);
+  const loading = storefront.stateFactory(`activation-request-${(0, import_vue2.toValue)(token)}-loading`, true);
+  const fulfilling = storefront.stateFactory(`activation-request-${(0, import_vue2.toValue)(token)}-fulfilling`, false);
+  const completing = storefront.stateFactory(`activation-request-${(0, import_vue2.toValue)(token)}-completing`, false);
+  const completionTimeout = storefront.stateFactory(`activation-request-${(0, import_vue2.toValue)(token)}-completion-timeout`, null);
   const checkCompletion = async () => {
     if (!activationRequest.value)
       return;
@@ -461,7 +386,7 @@ function useActivationRequest(token, context) {
       completionTimeout.value = setTimeout(checkCompletion, 1500);
     }
   };
-  (0, import_vue7.watch)(() => (0, import_vue7.toValue)(token), async (newRequestId) => {
+  (0, import_vue2.watch)(() => (0, import_vue2.toValue)(token), async (newRequestId) => {
     try {
       if (newRequestId && newRequestId.length > 0) {
         activationRequest.value = await storefront.client.activationRequests.get(newRequestId);
@@ -478,13 +403,13 @@ function useActivationRequest(token, context) {
       loading.value = false;
     }
   }, { immediate: true });
-  (0, import_vue7.onBeforeUnmount)(() => {
+  (0, import_vue2.onBeforeUnmount)(() => {
     if (completionTimeout.value)
       clearTimeout(completionTimeout.value);
   });
-  (0, import_vue7.watch)(storefront.currentUser, async () => {
+  (0, import_vue2.watch)(storefront.currentUser, async () => {
     var _a, _b;
-    const requestId = (0, import_vue7.toValue)(token);
+    const requestId = (0, import_vue2.toValue)(token);
     if (!requestId || ((_b = (_a = activationRequest.value) == null ? void 0 : _a.licenseEligibility) == null ? void 0 : _b.eligible))
       return;
     loading.value = true;
@@ -505,7 +430,7 @@ function useActivationRequest(token, context) {
     fulfilling,
     completing,
     error,
-    isInstalled: (0, import_vue7.computed)(() => {
+    isInstalled: (0, import_vue2.computed)(() => {
       var _a;
       return activationRequest && ((_a = activationRequest.value) == null ? void 0 : _a.status) === import_storefront_api3.ActivationRequestStatus.Completed;
     }),
@@ -531,44 +456,99 @@ function useActivationRequest(token, context) {
   };
 }
 
-// src/composables/useVoucher.ts
-var import_storefront_api4 = require("@moonbase.sh/storefront-api");
-var import_vue8 = require("vue");
-function useVoucher(context) {
-  const storefront = context != null ? context : (0, import_vue8.inject)(storefrontKey);
+// src/composables/useAuth.ts
+var import_vue3 = require("vue");
+function useAuth(context) {
+  const storefront = context != null ? context : (0, import_vue3.inject)(storefrontKey);
   if (!storefront)
     throw new Error("No storefront configured");
   return {
-    peek: async (code) => {
-      try {
-        return await storefront.client.vouchers.peek(code);
-      } catch (e) {
-        if (e instanceof import_storefront_api4.NotFoundError)
-          throw new Error("Voucher code invalid");
-        throw e;
-      }
+    user: storefront.currentUser,
+    loaded: storefront.loadedUser,
+    loadedPromise: storefront.loadedUserPromise,
+    signIn: async (email, password) => {
+      const user = await storefront.client.identity.signIn(email, password);
+      storefront.currentUser.value = user;
+      const _ = storefront.updateStorefront();
+      return user;
     },
-    redeem: async (code) => {
-      try {
-        return await storefront.client.vouchers.redeem(code);
-      } catch (e) {
-        if (e instanceof import_storefront_api4.NotFoundError)
-          throw new Error("Voucher code invalid");
-        throw e;
+    signUp: async (name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) => {
+      const user = await storefront.client.identity.signUp(
+        name,
+        email,
+        password,
+        address,
+        acceptedPrivacyPolicy,
+        acceptedTermsAndConditions,
+        communicationOptIn
+      );
+      storefront.currentUser.value = user;
+      const _ = storefront.updateStorefront();
+      return user;
+    },
+    signOut: async () => {
+      storefront.client.tokenStore.setUser(null);
+      await Promise.all([storefront.updateStorefront(), storefront.surrenderOrder()]);
+      storefront.currentUser.value = null;
+    },
+    update: async (name, email, emailConfirmationToken, communicationPreferences) => {
+      const result = await storefront.client.identity.update(name, email, emailConfirmationToken, communicationPreferences);
+      if (storefront.currentUser.value) {
+        storefront.currentUser.value.name = name;
+        if (communicationPreferences)
+          storefront.currentUser.value.communicationPreferences = communicationPreferences;
       }
+      return result;
+    },
+    setPassword: async (currentPassword, newPassword) => {
+      await storefront.client.identity.setPassword(currentPassword, newPassword);
+    },
+    forgotPassword: async (email) => {
+      await storefront.client.identity.forgotPassword(email);
+    },
+    resetPassword: async (email, newPassword, code) => {
+      await storefront.client.identity.resetPassword(email, newPassword, code);
+    },
+    confirmAccount: async (email, code) => {
+      return await storefront.client.identity.confirmAccount(email, code);
+    },
+    confirmEmail: async (email, code) => {
+      return await storefront.client.identity.confirmEmail(email, code);
+    },
+    confirmEmailChange: async (email, code) => {
+      await storefront.client.identity.confirmEmailChange(email, code);
+      return await storefront.updateUser();
     }
   };
 }
 
+// src/composables/useBundle.ts
+var import_vue4 = require("vue");
+function useBundle(bundleId, context) {
+  const storefront = context != null ? context : (0, import_vue4.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return (0, import_vue4.computed)(() => storefront.storefront.value.bundles.find((b) => b.id === bundleId) || null);
+}
+
+// src/composables/useBundles.ts
+var import_vue5 = require("vue");
+function useBundles(context) {
+  const storefront = context != null ? context : (0, import_vue5.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return (0, import_vue5.computed)(() => storefront.storefront.value.bundles);
+}
+
 // src/composables/useCart.ts
-var import_vue9 = require("vue");
-var import_storefront_api5 = require("@moonbase.sh/storefront-api");
+var import_storefront_api4 = require("@moonbase.sh/storefront-api");
+var import_vue6 = require("vue");
 function useCart(context) {
-  const storefront = context != null ? context : (0, import_vue9.inject)(storefrontKey);
+  const storefront = context != null ? context : (0, import_vue6.inject)(storefrontKey);
   if (!storefront)
     throw new Error("No storefront configured");
   return {
-    items: (0, import_vue9.computed)(() => storefront.currentOrder.value.items.map((item) => {
+    items: (0, import_vue6.computed)(() => storefront.currentOrder.value.items.map((item) => {
       var _a, _b;
       if (item.type === "Product") {
         const product = storefront.storefront.value.products.find((p) => p.id === item.productId);
@@ -594,8 +574,8 @@ function useCart(context) {
         };
       }
     })),
-    currency: (0, import_vue9.computed)(() => storefront.currentOrder.value.currency || storefront.storefront.value.suggestedCurrency),
-    total: (0, import_vue9.computed)(() => {
+    currency: (0, import_vue6.computed)(() => storefront.currentOrder.value.currency || storefront.storefront.value.suggestedCurrency),
+    total: (0, import_vue6.computed)(() => {
       const currency = storefront.currentOrder.value.currency || storefront.storefront.value.suggestedCurrency;
       const total = storefront.currentOrder.value.items.reduce((agg, item) => {
         var _a, _b, _c, _d, _e, _f;
@@ -616,7 +596,7 @@ function useCart(context) {
       return { amount: total, currency };
     }),
     addToCart: (item, variation) => {
-      item = (0, import_vue9.unref)(item);
+      item = (0, import_vue6.unref)(item);
       variation != null ? variation : variation = item.defaultVariation;
       if (!variation)
         throw new Error("Added item does not have a default variation, and none have been specified");
@@ -650,7 +630,7 @@ function useCart(context) {
           };
           storefront.currentOrder.value.items.push(lineItem);
         } else {
-          throw new import_storefront_api5.MoonbaseError("Invalid input", `Could not handle item of type '${item.type}'`);
+          throw new import_storefront_api4.MoonbaseError("Invalid input", `Could not handle item of type '${item.type}'`);
         }
       } else {
         lineItem.quantity += 1;
@@ -700,80 +680,71 @@ function useCart(context) {
   };
 }
 
-// src/composables/useAuth.ts
-var import_vue10 = require("vue");
-function useAuth(context) {
-  const storefront = context != null ? context : (0, import_vue10.inject)(storefrontKey);
+// src/composables/useInventory.ts
+var import_vue7 = require("vue");
+function useInventory(context) {
+  const storefront = context != null ? context : (0, import_vue7.inject)(storefrontKey);
   if (!storefront)
     throw new Error("No storefront configured");
   return {
-    user: storefront.currentUser,
-    loaded: storefront.loadedUser,
-    loadedPromise: storefront.loadedUserPromise,
-    signIn: async (email, password) => {
-      const user = await storefront.client.identity.signIn(email, password);
-      storefront.currentUser.value = user;
-      const _ = storefront.updateStorefront();
-      return user;
-    },
-    signUp: async (name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) => {
-      const user = await storefront.client.identity.signUp(
-        name,
-        email,
-        password,
-        address,
-        acceptedPrivacyPolicy,
-        acceptedTermsAndConditions,
-        communicationOptIn
-      );
-      storefront.currentUser.value = user;
-      const _ = storefront.updateStorefront();
-      return user;
+    getLicenses: async (nextUrl) => {
+      return storefront.client.inventory.licenses.get(nextUrl);
     },
-    signOut: async () => {
-      storefront.client.tokenStore.setUser(null);
-      await Promise.all([storefront.updateStorefront(), storefront.surrenderOrder()]);
-      storefront.currentUser.value = null;
+    getLicenseActivations: async (licenseId, nextUrl) => {
+      return storefront.client.inventory.licenses.getActivations(licenseId, nextUrl);
     },
-    update: async (name, email, emailConfirmationToken, communicationPreferences) => {
-      const result = await storefront.client.identity.update(name, email, emailConfirmationToken, communicationPreferences);
-      if (storefront.currentUser.value) {
-        storefront.currentUser.value.name = name;
-        if (communicationPreferences)
-          storefront.currentUser.value.communicationPreferences = communicationPreferences;
-      }
-      return result;
+    getProduct: async (productId, version) => {
+      return storefront.client.inventory.products.get(productId, version);
     },
-    setPassword: async (currentPassword, newPassword) => {
-      await storefront.client.identity.setPassword(currentPassword, newPassword);
+    getProducts: async (nextUrl) => {
+      return storefront.client.inventory.products.getOwned(nextUrl);
     },
-    forgotPassword: async (email) => {
-      await storefront.client.identity.forgotPassword(email);
+    getProductLicenses: async (productId, nextUrl) => {
+      return storefront.client.inventory.products.getLicenses(productId, nextUrl);
     },
-    resetPassword: async (email, newPassword, code) => {
-      await storefront.client.identity.resetPassword(email, newPassword, code);
+    getProductActivations: async (productId, nextUrl) => {
+      return storefront.client.inventory.products.getActivations(productId, nextUrl);
     },
-    confirmAccount: async (email, code) => {
-      return await storefront.client.identity.confirmAccount(email, code);
+    revokeActivation: async (activation) => {
+      return storefront.client.inventory.licenses.revokeActivation(activation.licenseId, activation.id);
     },
-    confirmEmail: async (email, code) => {
-      return await storefront.client.identity.confirmEmail(email, code);
+    activateProduct: async (deviceToken, activationMethod) => {
+      return storefront.client.inventory.activation.activate(deviceToken, activationMethod);
     },
-    confirmEmailChange: async (email, code) => {
-      await storefront.client.identity.confirmEmailChange(email, code);
-      return await storefront.updateUser();
+    downloadProduct: async (download) => {
+      if (!download.path)
+        throw new Error("Product is not downloadable");
+      window.location.href = await storefront.client.inventory.products.getDownloadUrl(download.path);
     }
   };
 }
 
+// src/composables/useProduct.ts
+var import_vue8 = require("vue");
+function useProduct(productId, context) {
+  const storefront = context != null ? context : (0, import_vue8.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return (0, import_vue8.computed)(() => storefront.storefront.value.products.find((p) => p.id === productId) || null);
+}
+
+// src/composables/useProducts.ts
+var import_vue9 = require("vue");
+function useProducts(context) {
+  const storefront = context != null ? context : (0, import_vue9.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return (0, import_vue9.computed)(() => storefront.storefront.value.products);
+}
+
 // src/composables/useVendor.ts
-var import_vue11 = require("vue");
+var import_vue10 = require("vue");
 function useVendor(context) {
-  const storefront = context != null ? context : (0, import_vue11.inject)(storefrontKey);
+  const storefront = context != null ? context : (0, import_vue10.inject)(storefrontKey);
   if (!storefront)
     throw new Error("No storefront configured");
-  const vendor = (0, import_vue11.ref)(null);
-  const loading = (0, import_vue11.ref)(true);
+  const vendor = (0, import_vue10.ref)(null);
+  const loading = (0, import_vue10.ref)(true);
   storefront.client.vendor.get().then((v) => {
     vendor.value = v;
     loading.value = false;
@@ -784,7 +755,37 @@ function useVendor(context) {
   };
 }
 
+// src/composables/useVoucher.ts
+var import_storefront_api5 = require("@moonbase.sh/storefront-api");
+var import_vue11 = require("vue");
+function useVoucher(context) {
+  const storefront = context != null ? context : (0, import_vue11.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return {
+    peek: async (code) => {
+      try {
+        return await storefront.client.vouchers.peek(code);
+      } catch (e) {
+        if (e instanceof import_storefront_api5.NotFoundError)
+          throw new Error("Voucher code invalid");
+        throw e;
+      }
+    },
+    redeem: async (code) => {
+      try {
+        return await storefront.client.vouchers.redeem(code);
+      } catch (e) {
+        if (e instanceof import_storefront_api5.NotFoundError)
+          throw new Error("Voucher code invalid");
+        throw e;
+      }
+    }
+  };
+}
+
 // src/index.ts
+__reExport(src_exports, require("@moonbase.sh/storefront-api"), module.exports);
 function createStorefront(endpoint, stateFactory, config) {
   const configuration = {
     ...config != null ? config : {},