@moonbase.sh/vue 0.1.25

package/dist/index.cjs

@@ -0,0 +1,309 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createStorefront: () => createStorefront,
+  findBestPrice: () => findBestPrice,
+  storefrontKey: () => storefrontKey,
+  useAuth: () => useAuth,
+  useBundle: () => useBundle,
+  useBundles: () => useBundles,
+  useCart: () => useCart,
+  useProduct: () => useProduct,
+  useProducts: () => useProducts
+});
+module.exports = __toCommonJS(src_exports);
+var import_api_client3 = require("@moonbase.sh/api-client");
+
+// src/context.ts
+var import_api_client = require("@moonbase.sh/api-client");
+var import_uuid = require("uuid");
+var import_vue = require("vue");
+
+// src/symbols.ts
+var storefrontKey = Symbol("storefront");
+
+// src/utils/debounce.ts
+function debounce(func, waitMs = 100) {
+  let timeoutToken = 0;
+  const debounced = async (...args) => {
+    clearTimeout(timeoutToken);
+    timeoutToken = setTimeout(() => {
+      func(...args);
+    }, waitMs);
+  };
+  return debounced;
+}
+
+// src/context.ts
+var StorefrontContextImpl = class {
+  constructor(configuration, client) {
+    this.configuration = configuration;
+    this.client = client;
+    this.currentUser = (0, import_vue.ref)(null);
+    this.loadedUser = (0, import_vue.ref)(false);
+    this.debouncedPushOrderContent = debounce((order) => this.client.orders.pushContent(order), 500);
+    window.addEventListener("storage", (event) => this.handleStorageUpdate(event));
+    const cachedOrderJson = localStorage.getItem("moonbase_session");
+    if (cachedOrderJson) {
+      this.currentOrder = (0, import_vue.ref)(JSON.parse(cachedOrderJson));
+    } else {
+      this.currentOrder = (0, import_vue.ref)({
+        id: (0, import_uuid.v4)(),
+        status: import_api_client.OrderStatus.Open,
+        currency: "",
+        items: [],
+        couponsApplied: []
+      });
+      localStorage.setItem("moonbase_session", JSON.stringify(this.currentOrder.value));
+    }
+    const cachedStorefrontJson = localStorage.getItem("moonbase_storefront");
+    if (cachedStorefrontJson) {
+      this.storefront = (0, import_vue.ref)(JSON.parse(cachedStorefrontJson));
+      this.loadedStorefront = (0, import_vue.ref)(true);
+    } else {
+      this.storefront = (0, import_vue.ref)({
+        suggestedCurrency: "",
+        bundles: [],
+        products: []
+      });
+      this.loadedStorefront = (0, import_vue.ref)(false);
+    }
+    const _2 = this.updateStorefront();
+    const _3 = this.updateUser();
+  }
+  install(app) {
+    app.provide(storefrontKey, this);
+    console.log("Storefront installed");
+  }
+  async updateUser() {
+    try {
+      this.currentUser.value = await this.client.identity.get();
+    } catch (err) {
+      if (!(err instanceof import_api_client.NotAuthenticatedError))
+        console.error("Could not load user", err);
+    } finally {
+      this.loadedUser.value = true;
+    }
+  }
+  async updateStorefront() {
+    const latestStorefront = await this.client.storefront.get();
+    if (latestStorefront) {
+      localStorage.setItem("moonbase_storefront", JSON.stringify(latestStorefront));
+      this.storefront.value = latestStorefront;
+      this.loadedStorefront.value = true;
+      if (!this.currentOrder.value.currency) {
+        this.currentOrder.value.currency = latestStorefront.suggestedCurrency;
+        const _ = this.pushOrderContent();
+      }
+    }
+  }
+  async pushOrderContent() {
+    localStorage.setItem("moonbase_session", JSON.stringify(this.currentOrder.value));
+    const _ = this.debouncedPushOrderContent(this.currentOrder.value);
+  }
+  handleStorageUpdate(event) {
+    switch (event.key) {
+      case "moonbase_session":
+        this.currentOrder.value = JSON.parse(event.newValue);
+        break;
+      case "moonbase_storefront":
+        this.storefront.value = JSON.parse(event.newValue);
+        break;
+    }
+  }
+};
+
+// src/index.ts
+__reExport(src_exports, require("@moonbase.sh/api-client"), module.exports);
+
+// src/composables/useBundle.ts
+var import_vue2 = require("vue");
+function useBundle(bundleId) {
+  const storefront = (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() {
+  const storefront = (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) {
+  const storefront = (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() {
+  const storefront = (0, import_vue5.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return (0, import_vue5.computed)(() => storefront.storefront.value.products);
+}
+
+// src/composables/useCart.ts
+var import_api_client2 = require("@moonbase.sh/api-client");
+var import_vue6 = require("vue");
+
+// src/utils/findBestPrice.ts
+function findBestPrice(variations, currency, model) {
+  const prices = variations.filter((v) => v.model === model && v.prices[currency] !== void 0).map((v) => v.prices[currency]);
+  prices.sort((a, b) => b - a);
+  return prices.length === 0 ? 0 : prices[0];
+}
+
+// src/composables/useCart.ts
+function useCart() {
+  const storefront = (0, import_vue6.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return {
+    items: (0, import_vue6.computed)(() => storefront.currentOrder.value.items),
+    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;
+        let bestPrice;
+        if (item.type === "Product") {
+          const variations = ((_a = useProduct(item.productId).value) == null ? void 0 : _a.pricing) || [];
+          bestPrice = findBestPrice(variations, currency, item.pricingModel);
+        } else {
+          const variations = ((_b = useBundle(item.bundleId).value) == null ? void 0 : _b.pricing) || [];
+          bestPrice = findBestPrice(variations, currency, import_api_client2.PricingModel.Purchase);
+        }
+        return agg + bestPrice * item.quantity;
+      }, 0);
+      return { amount: total, currency };
+    }),
+    addToCart: (item, model = import_api_client2.PricingModel.Purchase) => {
+      let lineItem = storefront.currentOrder.value.items.find((i) => i.type === "Product" && i.productId === item.id && i.pricingModel === model || i.type === "Bundle" && i.bundleId === item.id);
+      if (!lineItem) {
+        if (item.type === "bundle") {
+          lineItem = {
+            type: "Bundle",
+            bundleId: item.id,
+            bundle: item,
+            quantity: 1
+          };
+          storefront.currentOrder.value.items.push(lineItem);
+        } else if (item.type === "product") {
+          lineItem = {
+            type: "Product",
+            pricingModel: model,
+            productId: item.id,
+            product: item,
+            quantity: 1
+          };
+          storefront.currentOrder.value.items.push(lineItem);
+        }
+      } else {
+        lineItem.quantity += 1;
+      }
+      const _ = storefront.pushOrderContent();
+    },
+    removeFromCart: (cartItem) => {
+      const index = storefront.currentOrder.value.items.findIndex((i) => i.type === "Bundle" && cartItem.type === "Bundle" && i.bundleId === cartItem.bundleId || i.type === "Product" && cartItem.type === "Product" && i.productId === cartItem.productId);
+      storefront.currentOrder.value.items.splice(index, 1);
+      const _ = storefront.pushOrderContent();
+    },
+    checkout: async (returnUrl) => {
+      const absoluteReturnUrl = new URL(returnUrl, document.baseURI).href;
+      const updatedOrder = await storefront.client.orders.pushContent(storefront.currentOrder.value, {
+        returnUrl: absoluteReturnUrl
+      });
+      storefront.currentOrder.value = updatedOrder;
+      if (updatedOrder.checkoutUrl)
+        window.location.href = updatedOrder.checkoutUrl;
+      else
+        throw new Error("No checkout URL found");
+    }
+  };
+}
+
+// src/composables/useAuth.ts
+var import_vue7 = require("vue");
+function useAuth() {
+  const storefront = (0, import_vue7.inject)(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return {
+    user: storefront.currentUser,
+    loaded: storefront.loadedUser,
+    signIn: async (email, password) => {
+      const user = await storefront.client.identity.signIn(email, password);
+      storefront.currentUser.value = user;
+      const _ = storefront.updateStorefront();
+      return user;
+    },
+    update: async (name, email, emailConfirmationToken) => {
+      const result = await storefront.client.identity.update(name, email, emailConfirmationToken);
+      if (storefront.currentUser.value)
+        storefront.currentUser.value.name = name;
+      return result;
+    },
+    setPassword: async (currentPassword, newPassword) => {
+      if (!storefront.currentUser.value)
+        throw new Error("No user loaded");
+      await storefront.client.identity.setPassword(storefront.currentUser.value.email, currentPassword, newPassword);
+    },
+    forgotPassword: async (email) => {
+      await storefront.client.identity.forgotPassword(email);
+    },
+    resetPassword: async (email, newPassword, code) => {
+      await storefront.client.identity.resetPassword(email, newPassword, code);
+    }
+  };
+}
+
+// src/index.ts
+function createStorefront(endpoint) {
+  const configuration = {
+    endpoint
+  };
+  return new StorefrontContextImpl(configuration, new import_api_client3.MoonbaseClient(configuration));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStorefront,
+  findBestPrice,
+  storefrontKey,
+  useAuth,
+  useBundle,
+  useBundles,
+  useCart,
+  useProduct,
+  useProducts,
+  ...require("@moonbase.sh/api-client")
+});

package/dist/index.d.cts

@@ -0,0 +1,77 @@
+import { Storefront, Order, User, MoonbaseClient, StorefrontBundle, StorefrontProduct, PricingModel, PricingVariation, OpenLineItem } from '@moonbase.sh/api-client';
+export * from '@moonbase.sh/api-client';
+import * as vue from 'vue';
+import { Ref, App, InjectionKey } from 'vue';
+
+interface StorefrontContext {
+    storefront: Ref<Storefront>;
+    loadedStorefront: Ref<boolean>;
+    currentOrder: Ref<Order>;
+    currentUser: Ref<User | null>;
+    loadedUser: Ref<boolean>;
+    client: MoonbaseClient;
+    updateStorefront(): Promise<void>;
+    pushOrderContent(): Promise<void>;
+    /**
+     * Called automatically by `app.use(storefront)`. Should not be called manually by
+     * the user.
+     *
+     * @internal
+     * @param app - Application that uses the storefront
+     */
+    install(app: App): any;
+}
+
+declare function useBundle(bundleId: string): Ref<StorefrontBundle | null>;
+
+declare function useBundles(): Ref<StorefrontBundle[]>;
+
+declare function useProduct(productId: string): Ref<StorefrontProduct | null>;
+
+declare function useProducts(): Ref<StorefrontProduct[]>;
+
+declare function useCart(): {
+    items: vue.ComputedRef<CartItem[]>;
+    currency: vue.ComputedRef<string>;
+    total: vue.ComputedRef<{
+        amount: number;
+        currency: string;
+    }>;
+    addToCart: (item: StorefrontProduct | StorefrontBundle, model?: PricingModel) => void;
+    removeFromCart: (cartItem: CartItem) => void;
+    checkout: (returnUrl: string) => Promise<void>;
+};
+
+declare function useAuth(): {
+    user: vue.Ref<{
+        id: string;
+        email: string;
+        name: string;
+        tenantId: string;
+    } | null>;
+    loaded: vue.Ref<boolean>;
+    signIn: (email: string, password: string) => Promise<{
+        id: string;
+        email: string;
+        name: string;
+        tenantId: string;
+    }>;
+    update: (name: string, email: string, emailConfirmationToken?: string) => Promise<{
+        needsEmailConfirmationToken: boolean;
+    }>;
+    setPassword: (currentPassword: string, newPassword: string) => Promise<void>;
+    forgotPassword: (email: string) => Promise<void>;
+    resetPassword: (email: string, newPassword: string, code: string) => Promise<void>;
+};
+
+declare const storefrontKey: InjectionKey<StorefrontContext>;
+
+declare function findBestPrice(variations: PricingVariation[], currency: string, model: PricingModel): number;
+
+interface Cart {
+    items: CartItem[];
+}
+type CartItem = OpenLineItem & {};
+declare function createStorefront(endpoint: string): StorefrontContext;
+
+export { Cart, CartItem, createStorefront, findBestPrice, storefrontKey, useAuth, useBundle, useBundles, useCart, useProduct, useProducts };

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { Storefront, Order, User, MoonbaseClient, StorefrontBundle, StorefrontProduct, PricingModel, PricingVariation, OpenLineItem } from '@moonbase.sh/api-client';
+export * from '@moonbase.sh/api-client';
+import * as vue from 'vue';
+import { Ref, App, InjectionKey } from 'vue';
+
+interface StorefrontContext {
+    storefront: Ref<Storefront>;
+    loadedStorefront: Ref<boolean>;
+    currentOrder: Ref<Order>;
+    currentUser: Ref<User | null>;
+    loadedUser: Ref<boolean>;
+    client: MoonbaseClient;
+    updateStorefront(): Promise<void>;
+    pushOrderContent(): Promise<void>;
+    /**
+     * Called automatically by `app.use(storefront)`. Should not be called manually by
+     * the user.
+     *
+     * @internal
+     * @param app - Application that uses the storefront
+     */
+    install(app: App): any;
+}
+
+declare function useBundle(bundleId: string): Ref<StorefrontBundle | null>;
+
+declare function useBundles(): Ref<StorefrontBundle[]>;
+
+declare function useProduct(productId: string): Ref<StorefrontProduct | null>;
+
+declare function useProducts(): Ref<StorefrontProduct[]>;
+
+declare function useCart(): {
+    items: vue.ComputedRef<CartItem[]>;
+    currency: vue.ComputedRef<string>;
+    total: vue.ComputedRef<{
+        amount: number;
+        currency: string;
+    }>;
+    addToCart: (item: StorefrontProduct | StorefrontBundle, model?: PricingModel) => void;
+    removeFromCart: (cartItem: CartItem) => void;
+    checkout: (returnUrl: string) => Promise<void>;
+};
+
+declare function useAuth(): {
+    user: vue.Ref<{
+        id: string;
+        email: string;
+        name: string;
+        tenantId: string;
+    } | null>;
+    loaded: vue.Ref<boolean>;
+    signIn: (email: string, password: string) => Promise<{
+        id: string;
+        email: string;
+        name: string;
+        tenantId: string;
+    }>;
+    update: (name: string, email: string, emailConfirmationToken?: string) => Promise<{
+        needsEmailConfirmationToken: boolean;
+    }>;
+    setPassword: (currentPassword: string, newPassword: string) => Promise<void>;
+    forgotPassword: (email: string) => Promise<void>;
+    resetPassword: (email: string, newPassword: string, code: string) => Promise<void>;
+};
+
+declare const storefrontKey: InjectionKey<StorefrontContext>;
+
+declare function findBestPrice(variations: PricingVariation[], currency: string, model: PricingModel): number;
+
+interface Cart {
+    items: CartItem[];
+}
+type CartItem = OpenLineItem & {};
+declare function createStorefront(endpoint: string): StorefrontContext;
+
+export { Cart, CartItem, createStorefront, findBestPrice, storefrontKey, useAuth, useBundle, useBundles, useCart, useProduct, useProducts };

package/dist/index.js

@@ -0,0 +1,274 @@
+// src/index.ts
+import { MoonbaseClient } from "@moonbase.sh/api-client";
+
+// src/context.ts
+import { NotAuthenticatedError, OrderStatus } from "@moonbase.sh/api-client";
+import { v4 as uuidv4 } from "uuid";
+import { ref } from "vue";
+
+// src/symbols.ts
+var storefrontKey = Symbol("storefront");
+
+// src/utils/debounce.ts
+function debounce(func, waitMs = 100) {
+  let timeoutToken = 0;
+  const debounced = async (...args) => {
+    clearTimeout(timeoutToken);
+    timeoutToken = setTimeout(() => {
+      func(...args);
+    }, waitMs);
+  };
+  return debounced;
+}
+
+// src/context.ts
+var StorefrontContextImpl = class {
+  constructor(configuration, client) {
+    this.configuration = configuration;
+    this.client = client;
+    this.currentUser = ref(null);
+    this.loadedUser = ref(false);
+    this.debouncedPushOrderContent = debounce((order) => this.client.orders.pushContent(order), 500);
+    window.addEventListener("storage", (event) => this.handleStorageUpdate(event));
+    const cachedOrderJson = localStorage.getItem("moonbase_session");
+    if (cachedOrderJson) {
+      this.currentOrder = ref(JSON.parse(cachedOrderJson));
+    } else {
+      this.currentOrder = ref({
+        id: uuidv4(),
+        status: OrderStatus.Open,
+        currency: "",
+        items: [],
+        couponsApplied: []
+      });
+      localStorage.setItem("moonbase_session", JSON.stringify(this.currentOrder.value));
+    }
+    const cachedStorefrontJson = localStorage.getItem("moonbase_storefront");
+    if (cachedStorefrontJson) {
+      this.storefront = ref(JSON.parse(cachedStorefrontJson));
+      this.loadedStorefront = ref(true);
+    } else {
+      this.storefront = ref({
+        suggestedCurrency: "",
+        bundles: [],
+        products: []
+      });
+      this.loadedStorefront = ref(false);
+    }
+    const _2 = this.updateStorefront();
+    const _3 = this.updateUser();
+  }
+  install(app) {
+    app.provide(storefrontKey, this);
+    console.log("Storefront installed");
+  }
+  async updateUser() {
+    try {
+      this.currentUser.value = await this.client.identity.get();
+    } catch (err) {
+      if (!(err instanceof NotAuthenticatedError))
+        console.error("Could not load user", err);
+    } finally {
+      this.loadedUser.value = true;
+    }
+  }
+  async updateStorefront() {
+    const latestStorefront = await this.client.storefront.get();
+    if (latestStorefront) {
+      localStorage.setItem("moonbase_storefront", JSON.stringify(latestStorefront));
+      this.storefront.value = latestStorefront;
+      this.loadedStorefront.value = true;
+      if (!this.currentOrder.value.currency) {
+        this.currentOrder.value.currency = latestStorefront.suggestedCurrency;
+        const _ = this.pushOrderContent();
+      }
+    }
+  }
+  async pushOrderContent() {
+    localStorage.setItem("moonbase_session", JSON.stringify(this.currentOrder.value));
+    const _ = this.debouncedPushOrderContent(this.currentOrder.value);
+  }
+  handleStorageUpdate(event) {
+    switch (event.key) {
+      case "moonbase_session":
+        this.currentOrder.value = JSON.parse(event.newValue);
+        break;
+      case "moonbase_storefront":
+        this.storefront.value = JSON.parse(event.newValue);
+        break;
+    }
+  }
+};
+
+// src/index.ts
+export * from "@moonbase.sh/api-client";
+
+// src/composables/useBundle.ts
+import { computed, inject } from "vue";
+function useBundle(bundleId) {
+  const storefront = inject(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return computed(() => storefront.storefront.value.bundles.find((b) => b.id === bundleId) || null);
+}
+
+// src/composables/useBundles.ts
+import { computed as computed2, inject as inject2 } from "vue";
+function useBundles() {
+  const storefront = inject2(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return computed2(() => storefront.storefront.value.bundles);
+}
+
+// src/composables/useProduct.ts
+import { computed as computed3, inject as inject3 } from "vue";
+function useProduct(productId) {
+  const storefront = inject3(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return computed3(() => storefront.storefront.value.products.find((p) => p.id === productId) || null);
+}
+
+// src/composables/useProducts.ts
+import { computed as computed4, inject as inject4 } from "vue";
+function useProducts() {
+  const storefront = inject4(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return computed4(() => storefront.storefront.value.products);
+}
+
+// src/composables/useCart.ts
+import { PricingModel } from "@moonbase.sh/api-client";
+import { computed as computed5, inject as inject5 } from "vue";
+
+// src/utils/findBestPrice.ts
+function findBestPrice(variations, currency, model) {
+  const prices = variations.filter((v) => v.model === model && v.prices[currency] !== void 0).map((v) => v.prices[currency]);
+  prices.sort((a, b) => b - a);
+  return prices.length === 0 ? 0 : prices[0];
+}
+
+// src/composables/useCart.ts
+function useCart() {
+  const storefront = inject5(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return {
+    items: computed5(() => storefront.currentOrder.value.items),
+    currency: computed5(() => storefront.currentOrder.value.currency || storefront.storefront.value.suggestedCurrency),
+    total: computed5(() => {
+      const currency = storefront.currentOrder.value.currency || storefront.storefront.value.suggestedCurrency;
+      const total = storefront.currentOrder.value.items.reduce((agg, item) => {
+        var _a, _b;
+        let bestPrice;
+        if (item.type === "Product") {
+          const variations = ((_a = useProduct(item.productId).value) == null ? void 0 : _a.pricing) || [];
+          bestPrice = findBestPrice(variations, currency, item.pricingModel);
+        } else {
+          const variations = ((_b = useBundle(item.bundleId).value) == null ? void 0 : _b.pricing) || [];
+          bestPrice = findBestPrice(variations, currency, PricingModel.Purchase);
+        }
+        return agg + bestPrice * item.quantity;
+      }, 0);
+      return { amount: total, currency };
+    }),
+    addToCart: (item, model = PricingModel.Purchase) => {
+      let lineItem = storefront.currentOrder.value.items.find((i) => i.type === "Product" && i.productId === item.id && i.pricingModel === model || i.type === "Bundle" && i.bundleId === item.id);
+      if (!lineItem) {
+        if (item.type === "bundle") {
+          lineItem = {
+            type: "Bundle",
+            bundleId: item.id,
+            bundle: item,
+            quantity: 1
+          };
+          storefront.currentOrder.value.items.push(lineItem);
+        } else if (item.type === "product") {
+          lineItem = {
+            type: "Product",
+            pricingModel: model,
+            productId: item.id,
+            product: item,
+            quantity: 1
+          };
+          storefront.currentOrder.value.items.push(lineItem);
+        }
+      } else {
+        lineItem.quantity += 1;
+      }
+      const _ = storefront.pushOrderContent();
+    },
+    removeFromCart: (cartItem) => {
+      const index = storefront.currentOrder.value.items.findIndex((i) => i.type === "Bundle" && cartItem.type === "Bundle" && i.bundleId === cartItem.bundleId || i.type === "Product" && cartItem.type === "Product" && i.productId === cartItem.productId);
+      storefront.currentOrder.value.items.splice(index, 1);
+      const _ = storefront.pushOrderContent();
+    },
+    checkout: async (returnUrl) => {
+      const absoluteReturnUrl = new URL(returnUrl, document.baseURI).href;
+      const updatedOrder = await storefront.client.orders.pushContent(storefront.currentOrder.value, {
+        returnUrl: absoluteReturnUrl
+      });
+      storefront.currentOrder.value = updatedOrder;
+      if (updatedOrder.checkoutUrl)
+        window.location.href = updatedOrder.checkoutUrl;
+      else
+        throw new Error("No checkout URL found");
+    }
+  };
+}
+
+// src/composables/useAuth.ts
+import { inject as inject6 } from "vue";
+function useAuth() {
+  const storefront = inject6(storefrontKey);
+  if (!storefront)
+    throw new Error("No storefront configured");
+  return {
+    user: storefront.currentUser,
+    loaded: storefront.loadedUser,
+    signIn: async (email, password) => {
+      const user = await storefront.client.identity.signIn(email, password);
+      storefront.currentUser.value = user;
+      const _ = storefront.updateStorefront();
+      return user;
+    },
+    update: async (name, email, emailConfirmationToken) => {
+      const result = await storefront.client.identity.update(name, email, emailConfirmationToken);
+      if (storefront.currentUser.value)
+        storefront.currentUser.value.name = name;
+      return result;
+    },
+    setPassword: async (currentPassword, newPassword) => {
+      if (!storefront.currentUser.value)
+        throw new Error("No user loaded");
+      await storefront.client.identity.setPassword(storefront.currentUser.value.email, currentPassword, newPassword);
+    },
+    forgotPassword: async (email) => {
+      await storefront.client.identity.forgotPassword(email);
+    },
+    resetPassword: async (email, newPassword, code) => {
+      await storefront.client.identity.resetPassword(email, newPassword, code);
+    }
+  };
+}
+
+// src/index.ts
+function createStorefront(endpoint) {
+  const configuration = {
+    endpoint
+  };
+  return new StorefrontContextImpl(configuration, new MoonbaseClient(configuration));
+}
+export {
+  createStorefront,
+  findBestPrice,
+  storefrontKey,
+  useAuth,
+  useBundle,
+  useBundles,
+  useCart,
+  useProduct,
+  useProducts
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@moonbase.sh/vue",
+  "type": "module",
+  "version": "0.1.25",
+  "description": "Package to let you build vue.js storefronts with Moonbase.sh as payment and delivery provider",
+  "author": "Tobias Lønnerød Madsen <m@dsen.tv>",
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts"
+  },
+  "dependencies": {
+    "@moonbase.sh/api-client": "workspace:*",
+    "@vue/devtools-api": "^6.5.0",
+    "uuid": "^9.0.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.2.0"
+  },
+  "devDependencies": {
+    "@types/uuid": "^9.0.1",
+    "rimraf": "^5.0.0",
+    "tsup": "^7.1.0",
+    "typescript": "~5.1.6",
+    "vue": "^3.3.4"
+  }
+}