@scayle/storefront-core 8.7.0 → 8.8.0

package/dist/index.d.ts

@@ -6,15 +6,63 @@ export * from './constants';
 export * from './cache';
 export * from './helpers';
 export * from './types';
+/**
+ * Core RPC methods available within `@scayle/storefront-core`.
+ */
 type RpcMethodsCore = typeof rpcMethods;
+/**
+ * Interface for extending RPC methods within `@scayle/storefront-core`. Allows custom RPC methods
+ * to be added to the SCAYLE Storefront application by extending this interface.
+ *
+ * @example
+ * ```typescript
+ * // nuxt.config.ts
+ * import * as customRpcMethods from './rpc'
+ * declare module '@scayle/storefront-core' {
+ *   export interface RpcMethodsStorefrontInternal extends typeof customRpcMethods {}
+ * }
+ * ```
+ */
 export interface RpcMethodsStorefrontInternal {
 }
+/**
+ * Combined RPC methods, merging core methods with SCAYLE Storefront application extensions.
+ * Extensions from `@scayle/storefront-core` take precedence in case of naming conflicts.
+ */
 export type RpcMethods = {
     [Key in keyof RpcMethodsCore | keyof RpcMethodsStorefrontInternal]: Key extends keyof RpcMethodsStorefrontInternal ? RpcMethodsStorefrontInternal[Key] : Key extends keyof RpcMethodsCore ? RpcMethodsCore[Key] : never;
 };
+/**
+ * Type alias representing the name of an RPC method.  This uses a
+ * resolution technique to avoid inlining method names in compiled
+ * type declarations, which is essential for supporting dynamically
+ * added RPC methods from the SCAYLE Storefront application.
+ *
+ * @see https://github.com/microsoft/TypeScript/pull/42149#issuecomment-865385560
+ * @
+ * Without this workaround, the signature to `rpcCall` looks something like
+ * `rpcCall(m: 'addItemToBasket' | 'addItemToWishlist'...)`.
+ * But we need it to look like `rpcCall(m: RpcMethodName)` in order to include
+ * RPC methods added by the SCAYLE Storefront application.
+ */
 type Resolve<T> = T extends T ? T : never;
 export type RpcMethodName = Resolve<keyof RpcMethods>;
+/**
+ * Describes the type of a specific RPC method by its name.
+ *
+ * @template N The name of the RPC method.
+ */
 export type RpcMethod<N extends RpcMethodName> = RpcMethods[N];
+/**
+ * Describes the type of the parameters for a specific RPC method.
+ *
+ * @template N The name of the RPC method.
+ */
 export type RpcMethodParameters<N extends RpcMethodName> = Parameters<RpcMethod<N>>[0];
+/**
+ * Describes the return type of a specific RPC method.
+ *
+ * @template N The name of the RPC method.
+ */
 export type RpcMethodReturnType<N extends RpcMethodName> = ReturnType<RpcMethod<N>>;
 export { ExistingItemHandling, AddToBasketFailureKind, UpdateBasketItemFailureKind, AddToWishlistFailureKind, PromotionEffectType, FilterTypes, APISortOption, APISortOrder, type ProductSortConfig, } from '@scayle/storefront-api';

package/dist/rpc/methods/basket/basket.mjs

@@ -9,6 +9,7 @@ import {
 import { mergeBaskets as mergeBasketFunction } from "../../../utils/user.mjs";
 import { unwrap } from "../../../utils/response.mjs";
 import { wasAddedWithReducedQuantity } from "../../../utils/index.mjs";
+import { getCampaignKey } from "../campaign.mjs";
 const SAPI_ERROR_NAME = "SAPI ERROR";
 function getWithParams(params, context) {
   return params.with ?? context.withParams?.basket ?? MIN_WITH_PARAMS_BASKET;
@@ -31,7 +32,8 @@ export const addItemToBasket = async function addItemToBasket2({
       "No Session found"
     );
   }
-  const { campaignKey, sapiClient, basketKey } = context;
+  const { sapiClient, basketKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = getWithParams(
     { with: _with },
     context
@@ -91,7 +93,8 @@ export const addItemsToBasket = async function addItemsToBasket2(params, context
       "No Session found"
     );
   }
-  const { campaignKey, sapiClient, basketKey } = context;
+  const { sapiClient, basketKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = getWithParams(params, context);
   const itemsToBeAddedOrUpdated = params.items.map((item) => ({
     variantId: item.variantId,
@@ -151,7 +154,8 @@ export const getBasket = async function getBasket2(options, context) {
       "No Session found"
     );
   }
-  const { sapiClient, campaignKey, basketKey } = context;
+  const { sapiClient, basketKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = getWithParams(
     { with: options },
     context
@@ -183,7 +187,8 @@ export const removeItemFromBasket = async function removeItemFromBasket2(options
       "No Session found"
     );
   }
-  const { sapiClient, campaignKey, basketKey } = context;
+  const { sapiClient, basketKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = getWithParams(options, context);
   const basket = await sapiClient.basket.deleteItem(
     basketKey,

package/dist/rpc/methods/campaign.d.ts

@@ -0,0 +1,13 @@
+import type { RpcContext } from '../../types';
+/**
+ * RPC method to retrieve the current campaign key.
+ * Used by other RPC methods which depend on a campaign key.
+ * Will return the key for the earliest active campaign.
+ *
+ * Uses SAPI's list-campaigns endpoint
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/campaigns/list-campaigns
+ *
+ * @param context The RPC Context
+ * @returns The current active campaign key.
+ */
+export declare const getCampaignKey: (context: RpcContext) => Promise<string | undefined>;

package/dist/rpc/methods/campaign.mjs

@@ -0,0 +1,23 @@
+import {
+  campaignHasNotEnded,
+  sortCampaignsByDateAscending,
+  isCampaignActive
+} from "../../utils/campaign.mjs";
+export const getCampaignKey = async (context) => {
+  if (context.campaignKey) {
+    return context.campaignKey;
+  }
+  const { cached, sapiClient } = context;
+  const { campaigns } = await cached(async () => {
+    const { entities } = await sapiClient.campaigns.get();
+    return {
+      campaigns: entities.filter((campaign) => {
+        return campaignHasNotEnded(campaign);
+      }).sort(sortCampaignsByDateAscending)
+    };
+  }, {
+    cacheKeyPrefix: "get-campaignKey",
+    ttl: 5 * 60
+  })();
+  return campaigns.find(isCampaignActive)?.key;
+};

package/dist/rpc/methods/checkout/checkout.mjs

@@ -3,6 +3,7 @@ import { hasSession } from "../../../types/index.mjs";
 import { ErrorResponse } from "../../../errors/index.mjs";
 import { HttpStatusCode, HttpStatusMessage } from "../../../constants/index.mjs";
 import { getAccessToken } from "../user.mjs";
+import { getCampaignKey } from "../campaign.mjs";
 export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}, context) {
   if (!hasSession(context)) {
     return new ErrorResponse(
@@ -28,14 +29,15 @@ export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}
   const secret = new TextEncoder().encode(context.checkout.secret);
   const now = /* @__PURE__ */ new Date();
   const { voucher, customData, preferredCollectionPoint, carrier } = jwtPayload;
+  const campaignKey = await getCampaignKey(context);
   const checkoutJwt = await new SignJWT({
     voucher,
     customData,
     preferredCollectionPoint,
     carrier,
     basketId: context.basketKey,
-    campaignKey: context.campaignKey
-  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.7.0"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
+    campaignKey
+  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.8.0"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
   return {
     accessToken: refreshedAccessToken,
     checkoutJwt

package/dist/rpc/methods/index.d.ts

@@ -1,6 +1,7 @@
 export * from './basket/basket';
 export * from './brands';
 export * from './categories';
+export { getCampaignKey } from './campaign';
 export * from './cbd';
 export { getProductById, getProductsByIds, getProductsByReferenceKeys, getProductsCount, fetchAllFiltersForCategory, getFilters, getProductsByCategory, } from './products';
 export * from './search';

package/dist/rpc/methods/index.mjs

@@ -1,6 +1,7 @@
 export * from "./basket/basket.mjs";
 export * from "./brands.mjs";
 export * from "./categories.mjs";
+export { getCampaignKey } from "./campaign.mjs";
 export * from "./cbd.mjs";
 export {
   getProductById,

package/dist/rpc/methods/products.d.ts

@@ -20,9 +20,9 @@ export declare function resolveCategoryIdFromParams(context: RpcContext, params:
     category: string | undefined;
     categoryId: number | undefined;
 }>;
-export declare const getProductById: (options: FetchProductParams, { sapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<Response | Product>;
-export declare const getProductsByIds: (options: FetchProductsByIdsParams, { sapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<Response | Product[]>;
-export declare const getProductsByReferenceKeys: (options: FetchProductsByReferenceKeysParams, { sapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<Response | Product[]>;
+export declare const getProductById: (options: FetchProductParams, context: RpcContext) => Promise<Response | Product>;
+export declare const getProductsByIds: (options: FetchProductsByIdsParams, context: RpcContext) => Promise<Response | Product[]>;
+export declare const getProductsByReferenceKeys: (options: FetchProductsByReferenceKeysParams, context: RpcContext) => Promise<Response | Product[]>;
 export declare const getProductsCount: (params: FetchProductsCountParams, context: RpcContext) => Promise<(string[] & ErrorResponse) | {
     count: number;
 }>;
@@ -31,7 +31,7 @@ export declare const fetchAllFiltersForCategory: ({ includedFilters, category }:
     category: {
         id?: number;
     };
-}, { cached, sapiClient, campaignKey }: RpcContext) => Promise<string[]>;
+}, context: RpcContext) => Promise<string[]>;
 export declare const getFilters: (params: FetchFiltersParams, context: RpcContext) => Promise<(string[] & ErrorResponse) | {
     filters: FiltersEndpointResponseData;
     unfilteredCount: number;

package/dist/rpc/methods/products.mjs

@@ -4,6 +4,7 @@ import { MINUTE } from "../../cache/index.mjs";
 import { unwrap } from "../../utils/response.mjs";
 import { mapSAPIFetchErrorToResponse } from "../../utils/sapi.mjs";
 import { ErrorResponse } from "../../errors/index.mjs";
+import { getCampaignKey } from "./campaign.mjs";
 const MAX_PER_PAGE = 100;
 const sanitizeAttributesForSAPI = ({
   attributes,
@@ -34,7 +35,9 @@ export async function resolveCategoryIdFromParams(context, params) {
   }
   return { category, categoryId };
 }
-export const getProductById = async function getProductById2(options, { sapiClient, cached, campaignKey, withParams }) {
+export const getProductById = async function getProductById2(options, context) {
+  const { sapiClient, cached, withParams } = context;
+  const campaignKey = await getCampaignKey(context);
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.products.getById),
     {
@@ -48,7 +51,9 @@ export const getProductById = async function getProductById2(options, { sapiClie
     includeSellableForFree: options.includeSellableForFree
   });
 };
-export const getProductsByIds = async function getProductsByIds2(options, { sapiClient, cached, campaignKey, withParams }) {
+export const getProductsByIds = async function getProductsByIds2(options, context) {
+  const { sapiClient, cached, withParams } = context;
+  const campaignKey = await getCampaignKey(context);
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.products.getByIds),
     {
@@ -61,7 +66,9 @@ export const getProductsByIds = async function getProductsByIds2(options, { sapi
     pricePromotionKey: options.pricePromotionKey
   });
 };
-export const getProductsByReferenceKeys = async function getProductsByReferenceKeys2(options, { sapiClient, cached, campaignKey, withParams }) {
+export const getProductsByReferenceKeys = async function getProductsByReferenceKeys2(options, context) {
+  const { sapiClient, cached, withParams } = context;
+  const campaignKey = await getCampaignKey(context);
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.products.getByReferenceKeys),
     {
@@ -82,7 +89,8 @@ export const getProductsCount = async function getProductsCount2(params, context
     includeSellableForFree = false,
     orFiltersOperator = void 0
   } = params;
-  const { cached, sapiClient, campaignKey } = context;
+  const { cached, sapiClient } = context;
+  const campaignKey = await getCampaignKey(context);
   const { categoryId } = await resolveCategoryIdFromParams(context, params);
   const response = await getSanitizedAttributes(
     context,
@@ -121,7 +129,9 @@ export const getProductsCount = async function getProductsCount2(params, context
     count: productCount?.pagination.total
   };
 };
-export const fetchAllFiltersForCategory = async function fetchAllFiltersForCategory2({ includedFilters = [], category }, { cached, sapiClient, campaignKey }) {
+export const fetchAllFiltersForCategory = async function fetchAllFiltersForCategory2({ includedFilters = [], category }, context) {
+  const { cached, sapiClient } = context;
+  const campaignKey = await getCampaignKey(context);
   const fetchAndMapFiltersToSlugs = async () => {
     const filtersFromSAPI = await cached(sapiClient.filters.get)({
       where: { categoryId: category.id },
@@ -162,7 +172,8 @@ export const getFilters = async function getFilters2(params, context) {
     includeSellableForFree = false,
     orFiltersOperator
   } = params;
-  const { cached, sapiClient, campaignKey } = context;
+  const { cached, sapiClient } = context;
+  const campaignKey = await getCampaignKey(context);
   const { category, categoryId } = await resolveCategoryIdFromParams(
     context,
     params
@@ -241,7 +252,8 @@ export const getProductsByCategory = async function getProductsByCategory2(param
     orFiltersOperator = void 0,
     trackSearchAnalyticsEvent = void 0
   } = params;
-  const { cached, sapiClient, campaignKey } = context;
+  const { cached, sapiClient } = context;
+  const campaignKey = await getCampaignKey(context);
   const { category, categoryId } = await resolveCategoryIdFromParams(
     context,
     params

package/dist/rpc/methods/variants.d.ts

@@ -5,4 +5,4 @@ export interface FetchVariantsParams {
     include?: ProductWith;
     pricePromotionKey?: string;
 }
-export declare const getVariantById: ({ ids, include, pricePromotionKey }: FetchVariantsParams, { sapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<Response | VariantDetail[]>;
+export declare const getVariantById: ({ ids, include, pricePromotionKey }: FetchVariantsParams, context: RpcContext) => Promise<Response | VariantDetail[]>;

package/dist/rpc/methods/variants.mjs

@@ -1,8 +1,11 @@
 import { mapSAPIFetchErrorToResponse } from "../../utils/sapi.mjs";
+import { getCampaignKey } from "./campaign.mjs";
 const defaultWith = {
   attributes: "all"
 };
-export const getVariantById = async function getVariantById2({ ids, include = defaultWith, pricePromotionKey = "default" }, { sapiClient, cached, campaignKey, withParams }) {
+export const getVariantById = async function getVariantById2({ ids, include = defaultWith, pricePromotionKey = "default" }, context) {
+  const { sapiClient, cached, withParams } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = include ?? withParams?.variant ?? defaultWith;
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.variants.getByIds),

package/dist/rpc/methods/wishlist.mjs

@@ -7,6 +7,7 @@ import {
 import { unwrap } from "../../utils/response.mjs";
 import { ErrorResponse } from "../../errors/index.mjs";
 import { mapSAPIFetchErrorToResponse } from "../../utils/sapi.mjs";
+import { getCampaignKey } from "./campaign.mjs";
 function getWithParams(params, context) {
   return params.with ?? context.withParams?.wishlist ?? MIN_WITH_PARAMS_WISHLIST;
 }
@@ -18,7 +19,8 @@ export const getWishlist = async function getWishlist2(options, context) {
       "No Session found"
     );
   }
-  const { sapiClient, campaignKey, wishlistKey } = context;
+  const { sapiClient, wishlistKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = getWithParams({ with: options }, context);
   return await mapSAPIFetchErrorToResponse(sapiClient.wishlist.get)(
     wishlistKey,
@@ -37,7 +39,8 @@ export const addItemToWishlist = async function addItemToWishlist2(options, cont
       "No Session found"
     );
   }
-  const { sapiClient, campaignKey, wishlistKey } = context;
+  const { sapiClient, wishlistKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const { productId, variantId } = options;
   const resolvedWith = getWithParams(options, context);
   const pricePromotionKey = resolvedWith?.pricePromotionKey ?? "";
@@ -73,7 +76,8 @@ export const removeItemFromWishlist = async function removeItemFromWishlist2(opt
       "No Session found"
     );
   }
-  const { sapiClient, campaignKey, wishlistKey } = context;
+  const { sapiClient, wishlistKey } = context;
+  const campaignKey = await getCampaignKey(context);
   const resolvedWith = getWithParams(options, context);
   return await mapSAPIFetchErrorToResponse(sapiClient.wishlist.deleteItem)(
     wishlistKey,

package/dist/types/api/context.d.ts

@@ -77,6 +77,9 @@ export type RpcContext = {
     shopId: number;
     domain?: string;
     withParams?: WithParams;
+    /**
+     * @deprecated Use the `getCampaignKey` RPC method instead.
+     */
     campaignKey?: string;
     destroySessionsForUserId: (userId: number, sessionsToKeep?: string[]) => Promise<void>;
     generateBasketKeyForUserId: (userId: string) => Promise<string>;

package/dist/utils/basket.d.ts

@@ -1,2 +1,25 @@
 import type { AddOrUpdateItemError } from '@scayle/storefront-api';
+/**
+ * Checks if all basket add/update errors indicate that items were added with reduced quantity.
+ * This function helps determine if a basket operation partially succeeded, meaning some items were added but with a lower quantity than requested.
+ *
+ * @param errors An array of `AddOrUpdateItemError` objects, typically returned from a basket add/update operation.
+ * @returns `true` if all errors indicate reduced quantity, `false` otherwise (including when the `errors` array is empty, null, or undefined).
+ *
+ * @example
+ * ```typescript
+ * const errors: AddOrUpdateItemError[] = [
+ *   { operation: 'add', kind: AddToBasketFailureKind.ITEM_ADDED_WITH_REDUCED_QUANTITY, variantId: 123 },
+ *   { operation: 'update', kind: UpdateBasketItemFailureKind.ITEM_ADDED_WITH_REDUCED_QUANTITY, variantId: 456 },
+ * ]
+ *
+ * const allReducedQuantity = wasAddedWithReducedQuantity(errors) // true
+ *
+ * const noErrors = wasAddedWithReducedQuantity() // false
+ *
+ * const otherErrors = wasAddedWithReducedQuantity([
+ *   { operation: 'add', kind: AddToBasketFailureKind.ITEM_NOT_FOUND, variantId: 789 },
+ * ]) // false
+ * ```
+ */
 export declare const wasAddedWithReducedQuantity: (errors?: AddOrUpdateItemError[]) => boolean;

package/dist/utils/campaign.d.ts

@@ -0,0 +1,23 @@
+import type { Campaign } from '@scayle/storefront-api';
+/**
+ * Determine if a campaign is active for the current date
+ *
+ * @param campaign the campaign to test
+ * @returns True when the current datetime is within the campaign's timeframe, false otherwise
+ */
+export declare const isCampaignActive: (campaign?: Campaign) => boolean;
+/**
+ * Determine if a campaign has ended based on the current datetime
+ *
+ * @param campaign
+ * @returns True if the campaign's end date is later than the current datetime, false otherwise
+ */
+export declare const campaignHasNotEnded: (campaign: Campaign) => boolean;
+/**
+ * Comparison function for campaigns based on their start date. To be used with Array.prototype.sort()
+ *
+ * @param a The first campaign for comparison
+ * @param b The second campaign for comparison
+ * @returns A positive value when a should come before b, negative value when b should come before a, or 0 when they are considered equal
+ */
+export declare const sortCampaignsByDateAscending: (a: Campaign, b: Campaign) => number;

package/dist/utils/campaign.mjs

@@ -0,0 +1,17 @@
+export const isCampaignActive = (campaign) => {
+  if (!campaign) {
+    return false;
+  }
+  const timeNow = Date.now();
+  const campaignStart = new Date(campaign.start_at).getTime();
+  const hasStarted = timeNow >= campaignStart;
+  const campaignEnd = new Date(campaign.end_at).getTime();
+  const hasEnded = timeNow >= campaignEnd;
+  return hasStarted && !hasEnded;
+};
+export const campaignHasNotEnded = (campaign) => {
+  return new Date(campaign.end_at).getTime() > Date.now();
+};
+export const sortCampaignsByDateAscending = (a, b) => {
+  return new Date(a.start_at).getTime() - new Date(b.start_at).getTime();
+};

package/dist/utils/fetch.d.ts

@@ -1,6 +1,25 @@
 /**
- * A custom Error type for errors that occur in a fetch() request
- * Contains the Response object from the request, and optionally the response data
+ * A custom Error type for errors that occur during a `fetch()` request.
+ * Includes the `Response` object and optional response data for more detailed error analysis.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const response = await fetch('/some/url')
+ *
+ *   if (!response.ok) {
+ *      const data = await response.json(); // Attempt to parse JSON error data
+ *      throw new FetchError(response, data)
+ *   }
+ *   // ... process successful response
+ * } catch (error) {
+ *   if (error instanceof FetchError) {
+ *     console.error("Fetch error:", error.message, error.response.status, error.data)
+ *   } else {
+ *     console.error("Other error:", error)
+ *   }
+ * }
+ * ```
  */
 export declare class FetchError extends Error {
     response: Response;

package/dist/utils/hash.d.ts

@@ -1,8 +1,75 @@
+/**
+ * Calculates the MD5 hash of a string.
+ * Uses `CryptoJS` for MD5 calculation.  Throws an error if MD5 support is omitted in the build.
+ *
+ * @see https://cryptojs.gitbook.io/docs/
+ *
+ * @param value The string to hash.
+ *
+ * @returns A Promise that resolves with the MD5 hash as a hex string.
+ *
+ * @throws {Error} If SFC is built without MD5 support (SFC_OMIT_MD5 environment variable is set).
+ */
 export declare const md5: (value: string) => Promise<any>;
+/**
+ * Calculates the SHA256 hash of a string.
+ *
+ * @param value The input string.
+ *
+ * @returns A Promise that resolves with the SHA256 hash as a hexadecimal string.
+ */
 export declare const sha256: (value: string) => Promise<string>;
+/**
+ * Calculates the HMAC (Hash-based Message Authentication Code) of a string.
+ *
+ * @param value The input string (message).
+ * @param secret The secret key.
+ * @param algorithm The hashing algorithm to use (e.g., 'SHA-256'). Defaults to 'SHA-256'.
+ *
+ * @returns A Promise that resolves with the HMAC as a hexadecimal string.
+ */
 export declare const hmac: (value: string, secret: string, algorithm?: string) => Promise<string>;
+/**
+ * Encodes a string to Base64. Works in both Node.js and browser environments.
+ *
+ * @param string The string to encode.
+ *
+ * @returns The Base64 encoded string.
+ */
 export declare const encodeBase64: (string: string) => string;
+/**
+ * Decodes a Base64 encoded string. Works in both Node.js and browser environments.
+ *
+ * @param string The Base64 encoded string.
+ *
+ * @returns The decoded string.
+ */
 export declare const decodeBase64: (string: string) => string;
+/**
+ * Verifies an order success token by comparing its signature with an expected signature.
+ *
+ * @template T The type of the parsed payload.
+ *
+ * @param token The token to verify.
+ * @param secret The secret key used to generate the signature.
+ *
+ * @returns A Promise resolving to the parsed token payload if the signature is valid, or undefined otherwise.
+ */
 export declare const verifyOrderSuccessToken: <T = unknown>(token: string, secret: string) => Promise<T | undefined>;
+/**
+ * Builds a hash payload by stringifying and Base64 encoding a given payload.
+ *
+ * @param payload The payload to hash.
+ *
+ * @returns The Base64 encoded hash payload.
+ */
 export declare const buildHashPayload: (payload: unknown) => string;
+/**
+ * Builds a signature for a given payload hash and secret.
+ *
+ * @param payloadHash The hash of the payload.
+ * @param secret The secret key.
+ *
+ * @returns A Promise resolving to the Base64 encoded signature.
+ */
 export declare const buildSignature: (payloadHash: string, secret: string) => Promise<string>;

package/dist/utils/hash.mjs

@@ -56,10 +56,10 @@ export const decodeBase64 = (string) => {
 export const verifyOrderSuccessToken = async (token, secret) => {
   const [encodedPayload, signature] = token.split(".", 2);
   const expectedSignature = encodeBase64(await hmac(encodedPayload, secret));
-  if (expectedSignature === signature) {
-    return JSON.parse(decodeBase64(encodedPayload));
+  if (expectedSignature !== signature) {
+    return;
   }
-  return void 0;
+  return JSON.parse(decodeBase64(encodedPayload));
 };
 export const buildHashPayload = (payload) => encodeBase64(JSON.stringify(payload));
 export const buildSignature = async (payloadHash, secret) => encodeBase64(await hmac(payloadHash, secret));

package/dist/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from './timeout';
 export * from './log';
 export * from './fetch';
 export * from './basket';
+export * from './campaign';

package/dist/utils/index.mjs

@@ -2,3 +2,4 @@ export * from "./timeout.mjs";
 export * from "./log.mjs";
 export * from "./fetch.mjs";
 export * from "./basket.mjs";
+export * from "./campaign.mjs";

package/dist/utils/keys.d.ts

@@ -1,6 +1,20 @@
 import type { Log } from '..';
 import { HashAlgorithm } from '../constants/hash';
+/**
+ * Generates a key based on a template, shop ID, user ID, and optional hash algorithm.
+ *
+ * @param params The required asynchronous function parameters.
+ * @param params.keyName Deprecated and unused value to specify the name of a key.
+ * @param params.keyTemplate The template string for the key, which can include placeholders for `shopId` and `userId`.
+ * @param params.hashAlgorithm The hash algorithm to use (MD5, SHA256, or none). Defaults to SHA256.
+ * @param params.shopId The shop ID.
+ * @param params.userId The user ID.
+ * @param params.log Optional logger instance.
+ *
+ * @returns A Promise resolving to the generated key.
+ */
 export declare const generateKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
+    /** @deprecated */
     keyName?: string;
     keyTemplate: string;
     hashAlgorithm: HashAlgorithm;
@@ -8,6 +22,18 @@ export declare const generateKey: ({ keyTemplate, hashAlgorithm, shopId, userId,
     userId: string;
     log?: Log;
 }) => Promise<string>;
+/**
+ * Generates a wishlist key.
+ *
+ * @param params The required asynchronous function parameters.
+ * @param params.keyTemplate The template string for the key.
+ * @param params.hashAlgorithm The hash algorithm to use. Defaults to SHA256.
+ * @param params.shopId The shop ID.
+ * @param params.userId The user ID.
+ * @param params.log Optional logger instance.
+ *
+ * @returns A Promise resolving to the generated wishlist key.
+ */
 export declare const generateWishlistKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
     keyTemplate: string;
     hashAlgorithm: HashAlgorithm;
@@ -15,6 +41,18 @@ export declare const generateWishlistKey: ({ keyTemplate, hashAlgorithm, shopId,
     userId: string;
     log?: Log;
 }) => Promise<string>;
+/**
+ * Generates a basket key.
+ *
+ * @param params The required asynchronous function parameters.
+ * @param params.keyTemplate The template string for the key.
+ * @param params.hashAlgorithm The hash algorithm to use. Defaults to SHA256.
+ * @param params.shopId The shop ID.
+ * @param params.userId The user ID.
+ * @param params.log Optional logger instance.
+ *
+ * @returns A Promise resolving to the generated basket key.
+ */
 export declare const generateBasketKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
     keyTemplate: string;
     hashAlgorithm: HashAlgorithm;