@scayle/storefront-nuxt 7.36.3

package/dist/runtime/composables/storefront/useShopConfiguration.mjs

@@ -0,0 +1,19 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useShopConfiguration({
+  options,
+  key = "useShopConfiguration"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getShopConfiguration",
+    key,
+    void 0,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

package/dist/runtime/composables/storefront/useUserAddresses.d.ts

@@ -0,0 +1,13 @@
+import { RpcOptions } from '../core/useRpc';
+type Options = Partial<{
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useUserAddresses({ options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").ShopUserAddress[]>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

package/dist/runtime/composables/storefront/useUserAddresses.mjs

@@ -0,0 +1,19 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useUserAddresses({
+  options,
+  key = "useUserAddresses"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getShopUserAddresses",
+    key,
+    void 0,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

package/dist/runtime/composables/storefront/useVariant.d.ts

@@ -0,0 +1,16 @@
+import { type RpcMethodParameters } from '@scayle/storefront-core';
+import { type RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getVariantById'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useVariant({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<VariantDetail[]>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

package/dist/runtime/composables/storefront/useVariant.mjs

@@ -0,0 +1,20 @@
+import { useRpc } from "../core/useRpc.mjs";
+export async function useVariant({
+  params,
+  options,
+  key = "useVariant"
+} = {}) {
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getVariantById",
+    key,
+    params,
+    options
+  );
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+}

package/dist/runtime/composables/storefront/useWishlist.d.ts

@@ -0,0 +1,48 @@
+import { Product, WishlistItem, RpcMethodParameters } from '@scayle/storefront-core';
+import { RpcOptions } from '../core/useRpc';
+import { type MaybeRefOrGetter } from '#imports';
+type Options = Partial<{
+    params: MaybeRefOrGetter<RpcMethodParameters<'getWishlist'>>;
+    options: RpcOptions;
+    key: string;
+}>;
+export declare function useWishlist({ params, options, key, }?: Options): Promise<{
+    data: import("vue").Ref<import("@scayle/storefront-core").WishlistResponseData>;
+    count: import("vue").ComputedRef<number>;
+    items: import("vue").ComputedRef<WishlistItem[]>;
+    products: import("vue").ComputedRef<Product[]>;
+    addItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    removeItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    replaceItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }, newItem: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    clear: () => Promise<void>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    toggleItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => Promise<void>;
+    findItem: (item: {
+        variantId?: number;
+        productId?: number;
+    }) => WishlistItem | undefined;
+    contains: (item: {
+        variantId: number;
+    } | {
+        productId: number;
+    }) => boolean;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("../core/useRpc").Status>;
+}>;
+export {};

package/dist/runtime/composables/storefront/useWishlist.mjs

@@ -0,0 +1,119 @@
+import {
+  BaseError,
+  HttpStatusMessage,
+  HttpStatusCode
+} from "@scayle/storefront-core";
+import { useNuxtApp } from "nuxt/app";
+import { computed } from "vue";
+import { rpcCall } from "../../rpc/rpcCall.mjs";
+import { useCurrentShop } from "../core/useCurrentShop.mjs";
+import { useRpc } from "../core/useRpc.mjs";
+import { toValue } from "#imports";
+export async function useWishlist({
+  params,
+  options,
+  key = "useWishlist"
+} = {}) {
+  const nuxtApp = useNuxtApp();
+  const shop = useCurrentShop();
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getWishlist",
+    key,
+    params,
+    options
+  );
+  const addItem = async (item) => {
+    data.value = await rpcCall(
+      nuxtApp,
+      "addItemToWishlist",
+      toValue(shop)
+    )({
+      ...item,
+      with: toValue(params)
+    });
+  };
+  const removeItem = async (item) => {
+    const element = findItem(item);
+    if (!element) {
+      throw new BaseError(
+        HttpStatusMessage.NOT_FOUND,
+        HttpStatusCode.NOT_FOUND,
+        "Could not find wishlist item."
+      );
+    }
+    data.value = await rpcCall(
+      nuxtApp,
+      "removeItemFromWishlist",
+      toValue(shop)
+    )({
+      itemKey: element.key,
+      with: toValue(params)
+    });
+  };
+  const replaceItem = async (item, newItem) => {
+    const element = findItem(item);
+    if (!element) {
+      throw new BaseError(
+        HttpStatusMessage.NOT_FOUND,
+        HttpStatusCode.NOT_FOUND,
+        `Could not find wishlist item by: ${JSON.stringify(item)}`
+      );
+    }
+    await rpcCall(
+      nuxtApp,
+      "removeItemFromWishlist",
+      toValue(shop)
+    )({
+      with: toValue(params),
+      itemKey: element.key
+    });
+    data.value = await rpcCall(
+      nuxtApp,
+      "addItemToWishlist",
+      toValue(shop)
+    )({
+      ...newItem,
+      with: toValue(params)
+    });
+  };
+  const clear = async () => {
+    data.value = await rpcCall(nuxtApp, "clearWishlist", toValue(shop))();
+  };
+  const findItem = (item) => {
+    return data.value?.items?.find((entry) => {
+      if ("variantId" in item) {
+        return entry.variant?.id === item.variantId;
+      }
+      return entry.product?.id === item.productId;
+    });
+  };
+  const contains = (item) => {
+    return findItem(item) !== void 0;
+  };
+  const toggleItem = async (item) => {
+    const element = findItem(item);
+    await (element ? removeItem(item) : addItem(item));
+  };
+  const count = computed(() => data.value?.items.length);
+  const items = computed(() => data.value?.items);
+  const products = computed(() => {
+    return items.value?.map((item) => item.product) || [];
+  });
+  return {
+    data,
+    count,
+    items,
+    products,
+    addItem,
+    removeItem,
+    replaceItem,
+    clear,
+    fetching,
+    fetch,
+    toggleItem,
+    findItem,
+    contains,
+    error,
+    status
+  };
+}

package/dist/runtime/composables/useCoreLog.d.ts

@@ -0,0 +1 @@
+export declare function useCoreLog(subSpace: string): any;

package/dist/runtime/composables/useCoreLog.mjs

@@ -0,0 +1,4 @@
+import { useLog } from "./core/useLog.mjs";
+export function useCoreLog(subSpace) {
+  return useLog(subSpace ? `sfc.${subSpace}` : "sfc");
+}

package/dist/runtime/context.d.ts

@@ -0,0 +1,12 @@
+import { Log, RpcContext, Cache as CacheInterface } from '@scayle/storefront-core';
+import type { Session } from '@scayle/h3-session';
+import { ShopConfig, StorefrontConfig } from '../module';
+export interface ContextBuilderOptions {
+    $cache: CacheInterface;
+    $shopConfig: ShopConfig;
+    $storefront: StorefrontConfig;
+    $log: Log;
+    sessionId: string;
+    session: Session;
+}
+export declare const buildContext: (context: ContextBuilderOptions) => Promise<RpcContext>;

package/dist/runtime/context.mjs

@@ -0,0 +1,98 @@
+import {
+  Cached
+} from "@scayle/storefront-core";
+import { init as initBapi } from "@scayle/storefront-core/dist/bapi/init";
+import {
+  generateBasketKey,
+  generateWishlistKey
+} from "@scayle/storefront-core/dist/utils/keys";
+export const buildContext = async (context) => {
+  const { $cache, $shopConfig, $storefront, $log, session } = context;
+  const bapiConfig = $shopConfig.bapi ?? $storefront.bapi;
+  const appKeys = $shopConfig.appKeys ?? $storefront.appKeys;
+  return {
+    cached: new Cached($cache, $log, "", $storefront.cache?.enabled ?? true).execute,
+    bapiClient: initBapi({
+      host: bapiConfig.host,
+      shopId: $shopConfig.shopId,
+      authentication: "token",
+      token: bapiConfig.token
+    }),
+    wishlistKey: session.data.user ? await generateWishlistKey({
+      keyTemplate: appKeys.wishlistKey,
+      userId: String(session.data.user.id),
+      shopId: String($shopConfig.shopId),
+      hashAlgorithm: appKeys.hashAlgorithm,
+      log: $log
+    }) : session.id,
+    basketKey: session.data.user ? await generateBasketKey({
+      keyTemplate: appKeys.basketKey,
+      userId: String(session.data.user.id),
+      shopId: String($shopConfig.shopId),
+      hashAlgorithm: appKeys.hashAlgorithm,
+      log: $log
+    }) : session.id,
+    auth: {
+      resetPasswordUrl: $shopConfig.auth?.resetPasswordUrl
+    },
+    checkout: {
+      url: $shopConfig.checkout.host,
+      secret: $shopConfig.checkout.secret,
+      token: $shopConfig.checkout.token,
+      user: $shopConfig.checkout.user,
+      cbdExpiration: $shopConfig.checkout.cbdExpiration
+    },
+    oauth: {
+      clientId: $storefront.oauth.clientId,
+      clientSecret: $storefront.oauth.clientSecret,
+      apiHost: $storefront.oauth.apiHost
+    },
+    log: $log,
+    get user() {
+      return session.data?.user ?? void 0;
+    },
+    destroySession: async () => {
+      await session.destroy();
+    },
+    destroySessionsForUserId: async () => {
+    },
+    createUserBoundSession: async () => {
+      $log.debug("creating user bound session");
+      const data = session.data;
+      await session.regenerate();
+      session.data = data;
+      await session.save();
+    },
+    generateBasketKeyForUserId: (userId) => generateBasketKey({
+      keyTemplate: appKeys.basketKey,
+      userId,
+      shopId: String($shopConfig.shopId),
+      hashAlgorithm: appKeys.hashAlgorithm,
+      log: $log
+    }),
+    generateWishlistKeyForUserId: (userId) => generateWishlistKey({
+      keyTemplate: appKeys.wishlistKey,
+      userId,
+      shopId: String($shopConfig.shopId),
+      hashAlgorithm: appKeys.hashAlgorithm,
+      log: $log
+    }),
+    isCmsPreview: false,
+    locale: $shopConfig.locale,
+    shopId: $shopConfig.shopId,
+    domain: $shopConfig.domain,
+    withParams: $storefront.withParams,
+    updateUser: async (user) => {
+      session.data.user = user;
+      await session.save();
+    },
+    sessionId: context.sessionId,
+    get accessToken() {
+      return session.data?.accessToken ?? void 0;
+    },
+    updateTokens: async (tokens) => {
+      Object.assign(session.data, tokens);
+      await session.save();
+    }
+  };
+};

package/dist/runtime/createLog.d.ts

@@ -0,0 +1,3 @@
+import type { ConsolaInstance, ConsolaOptions } from 'consola';
+import { Log } from './log';
+export default function createLog(createConsola: (options?: Partial<ConsolaOptions>) => ConsolaInstance, space?: string): Log;

package/dist/runtime/createLog.mjs

@@ -0,0 +1,39 @@
+import { Log } from "./log.mjs";
+const isProd = process.env.APP_ENV === "production";
+function prepareData(data) {
+  if (!data) {
+    return data;
+  }
+  if (data.response) {
+    const { response, message, name, code, ...other } = data;
+    return {
+      message,
+      name,
+      code,
+      status: response?.status,
+      statusText: response?.statusText,
+      ...other
+    };
+  }
+  return data;
+}
+export default function createLog(createConsola, space = "default-storefront") {
+  const logger = createConsola({
+    level: 4
+    // set to 3 to skip debug messages
+  });
+  const handler = (entry) => {
+    if (isProd && entry.level === "debug") {
+      return;
+    }
+    const data = prepareData(entry.data);
+    const log = logger[entry.level] || logger.info;
+    const message = `[${entry.space}] ${entry.message}`;
+    const args = data ? [message, data] : [message];
+    log.apply(log, args);
+  };
+  return new Log({
+    space,
+    handler
+  });
+}

package/dist/runtime/error/handler.d.ts

@@ -0,0 +1,14 @@
+import { HttpStatusCode } from '@scayle/storefront-core';
+import { FetchError } from 'ofetch';
+declare const parseErrorData: (error: unknown) => {
+    statusCode: HttpStatusCode;
+    statusMessage: string;
+    url?: string;
+};
+declare const resolveError: (error: FetchError | Error | unknown, additionalData?: unknown) => {
+    statusCode: 401 | 500 | 400 | 100 | 101 | 102 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+    statusMessage: string;
+    name: string;
+    data: unknown;
+};
+export { resolveError, parseErrorData };

package/dist/runtime/error/handler.mjs

@@ -0,0 +1,53 @@
+import {
+  BAPIError,
+  BaseError,
+  HttpStatusCode,
+  HttpStatusMessage
+} from "@scayle/storefront-core";
+import { FetchError } from "ofetch";
+const parseErrorData = (error) => {
+  if (error.isAxiosError) {
+    const err = error;
+    return {
+      statusCode: err.response?.data.code || HttpStatusCode.INTERNAL_SERVER_ERROR,
+      statusMessage: err.response?.data.message || HttpStatusMessage.INTERNAL_SERVER_ERROR,
+      url: err.config.url
+    };
+  }
+  if (error instanceof FetchError) {
+    const url = error.request?.url || String(error.request) || "/";
+    return {
+      statusCode: error.status || HttpStatusCode.INTERNAL_SERVER_ERROR,
+      statusMessage: error.statusText || HttpStatusMessage.INTERNAL_SERVER_ERROR,
+      url
+    };
+  } else if (error instanceof BAPIError) {
+    return {
+      statusCode: error.statusCode || HttpStatusCode.INTERNAL_SERVER_ERROR,
+      statusMessage: error.message || HttpStatusMessage.INTERNAL_SERVER_ERROR,
+      url: error.url
+    };
+  } else if (error instanceof BaseError) {
+    return {
+      statusCode: error.statusCode || HttpStatusCode.INTERNAL_SERVER_ERROR,
+      statusMessage: error.message || HttpStatusMessage.INTERNAL_SERVER_ERROR
+    };
+  } else if (error instanceof Error) {
+    return {
+      statusCode: HttpStatusCode.INTERNAL_SERVER_ERROR,
+      statusMessage: error.message || HttpStatusMessage.INTERNAL_SERVER_ERROR
+    };
+  }
+  return {
+    statusCode: HttpStatusCode.INTERNAL_SERVER_ERROR,
+    statusMessage: HttpStatusMessage.INTERNAL_SERVER_ERROR
+  };
+};
+const resolveError = (error, additionalData) => {
+  const { statusCode, statusMessage } = parseErrorData(error);
+  const [key] = Object.entries(HttpStatusCode).find(([_, code]) => code === statusCode) || [];
+  const statusCodeKey = key;
+  const name = statusCodeKey ? HttpStatusMessage[statusCodeKey] : HttpStatusMessage.INTERNAL_SERVER_ERROR;
+  return { statusCode, statusMessage, name, data: additionalData };
+};
+export { resolveError, parseErrorData };

package/dist/runtime/handler.d.ts

@@ -0,0 +1,8 @@
+import { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+/**
+ * Handler for RPC methods
+ * @param method
+ * @param payload
+ * @param rpcContext
+ */
+export declare const handler: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean, TParams = TakesParameters extends undefined ? null : P>(method: N, payload: TParams, rpcContext: RpcContext) => Promise<TResult>;

package/dist/runtime/handler.mjs

@@ -0,0 +1,26 @@
+import {
+  rpcMethods as coreRpcMethods
+} from "@scayle/storefront-core";
+import * as storefrontRpcMethods from "#rpcMethods";
+export const handler = async (method, payload, rpcContext) => {
+  const rpcMethods = {
+    ...coreRpcMethods,
+    ...storefrontRpcMethods
+  };
+  if (!Object.hasOwn(rpcMethods, method)) {
+    throw new Error(`RPC Method [${method}] was not found`);
+  }
+  const log = rpcContext.log.space("sfc").space("rpc");
+  return await log.time(`Calling RPC method: ${method}`, async () => {
+    const fun = rpcMethods[method];
+    if (fun.length === 1) {
+      return await fun(
+        rpcContext
+      );
+    }
+    return await fun(
+      payload,
+      rpcContext
+    );
+  });
+};

package/dist/runtime/log.d.ts

@@ -0,0 +1,38 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    level: LogLevel;
+    space: string;
+    message: string;
+    data?: Object;
+}
+export type LogHandler = (entry: LogEntry) => void;
+export interface LogOptions {
+    handler?: LogHandler;
+    space: string;
+}
+/**
+ * This log provides a way to log messages to a custom log handler (in a serial manner).
+ * If no handler is provided, it will log to the console.
+ */
+export declare class Log {
+    static default: Log;
+    _handler?: LogHandler;
+    _space: string;
+    _type: string;
+    constructor(options?: LogOptions);
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string | Error, data?: any): void;
+    write(level: LogLevel, message: string, data?: any): void;
+    /**
+     * Create a new sub-space.
+     * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
+     * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+     */
+    space(subSpace: string): Log;
+    /**
+     * Measure the time of a function.
+     */
+    time<T>(message: string, func: () => T): Promise<T>;
+}

package/dist/runtime/log.mjs

@@ -0,0 +1,68 @@
+export class Log {
+  static default = new this({
+    space: "global",
+    handler: consoleLogHandler
+  });
+  _handler;
+  _space;
+  _type = "log";
+  constructor(options) {
+    this._handler = options?.handler || Log.default._handler;
+    this._space = options?.space || Log.default._space;
+  }
+  debug(message, data) {
+    this.write("debug", message, data);
+  }
+  info(message, data) {
+    this.write("info", message, data);
+  }
+  warn(message, data) {
+    this.write("warn", message, data);
+  }
+  error(message, data) {
+    const error = message instanceof Error ? message : null;
+    if (error) {
+      data = {
+        error: message,
+        ...data
+      };
+    }
+    this.write("error", error?.message ?? message, data);
+  }
+  write(level, message, data) {
+    if (typeof data !== "undefined") {
+      data = typeof data !== "object" ? { data } : data;
+    }
+    if (this._handler) {
+      this._handler({ level, message, data, space: this._space });
+    } else {
+      const logFunc = console[level] || console.log;
+      logFunc.apply(console, data ? [message, data] : [message]);
+    }
+  }
+  /**
+   * Create a new sub-space.
+   * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
+   * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+   */
+  space(subSpace) {
+    return new Log({
+      space: `${this._space}.${subSpace}`,
+      handler: this._handler
+    });
+  }
+  /**
+   * Measure the time of a function.
+   */
+  async time(message, func) {
+    const start = Date.now();
+    const result = await func();
+    const end = Date.now();
+    this.debug(`${message} took ${end - start}ms`);
+    return result;
+  }
+}
+function consoleLogHandler({ level, message, data }) {
+  const logFunc = console[level] || console.log;
+  logFunc.apply(console, data ? [message, data] : [message]);
+}

package/dist/runtime/plugin/log.client.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("nuxt/app").Plugin<{
+    log: import("../log").Log;
+    coreLog: import("../log").Log;
+}> & import("nuxt/app").ObjectPlugin<{
+    log: import("../log").Log;
+    coreLog: import("../log").Log;
+}>;
+export default _default;

package/dist/runtime/plugin/log.client.mjs

@@ -0,0 +1,24 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "nuxt/app";
+import { createConsola } from "consola/browser";
+import createLog from "../createLog.mjs";
+export default defineNuxtPlugin((nuxtApp) => {
+  const config = useRuntimeConfig().public;
+  const log = createLog(createConsola, config.log.name);
+  const coreLog = log.space("sfc");
+  coreLog.debug("Attached client-side logger");
+  addClientSideErrorHandling(log, nuxtApp.vueApp);
+  return {
+    provide: {
+      log,
+      coreLog
+    }
+  };
+});
+function addClientSideErrorHandling(log, app) {
+  app.config.warnHandler = (msg, vm, trace) => {
+    log.space("warnHandler").warn(msg, { vm, trace });
+  };
+  app.config.errorHandler = (error, vm, info) => {
+    log.space("errorHandler").error(error, { vm, info, component: vm?.$options.__name });
+  };
+}

package/dist/runtime/plugin/log.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;