@sonic-equipment/ui 0.0.119 → 1.0.0

package/dist/shared/api/bff/services/bff-service.js

@@ -0,0 +1,179 @@
+import { config } from '../../../../config.js';
+import { request } from '../../../fetch/request.js';
+import { isAnnouncementType, isAnnouncementSubtype } from '../../../model/announcement.js';
+import { TIME } from '../../../utils/time.js';
+
+async function fetchAnnouncements({ cultureCode, headers, ignoreCache, }) {
+    const { body } = await request({
+        headers: { ...headers, 'Current-Language-Id': cultureCode },
+        next: {
+            revalidate: ignoreCache ? 0 : 1 * TIME.DAY,
+            tags: ignoreCache
+                ? undefined
+                : ['announcements', `announcement-${cultureCode}`],
+        },
+        url: `${config.BFF_API_URL}/notification/announcement`,
+    });
+    if (typeof body === 'string')
+        return [];
+    return body.map(({ endDate, href, id, startDate, subType, text, title, type }) => {
+        if (!isAnnouncementType(type))
+            throw new Error(`Invalid announcement type: ${type}`);
+        if (!isAnnouncementSubtype(subType)) {
+            throw new Error(`Invalid announcement subType: ${subType}`);
+        }
+        return {
+            endDate: endDate ? new Date(endDate) : undefined,
+            href,
+            id,
+            startDate: startDate ? new Date(startDate) : undefined,
+            subType,
+            text,
+            title,
+            type,
+        };
+    });
+}
+async function fetchProductDetailsPageData({ cultureCode, headers, ignoreCache, pageUrl, }) {
+    const { body } = await request({
+        headers: { 'Current-Language-Id': cultureCode, ...headers },
+        next: {
+            revalidate: ignoreCache ? 0 : Infinity,
+            tags: ignoreCache
+                ? undefined
+                : [
+                    'product-details',
+                    `product-details-${pageUrl}`,
+                    `product-details-${pageUrl}-${cultureCode}`,
+                ],
+        },
+        url: `${config.BFF_API_URL}/pdp/?pageUrl=${pageUrl}`,
+    });
+    return body;
+}
+async function fetchProductListingPageData({ cultureCode, headers, ignoreCache, pageUrl, }) {
+    const { body } = await request({
+        headers: { 'Current-Language-Id': cultureCode, ...headers },
+        next: {
+            revalidate: ignoreCache ? 0 : Infinity,
+            tags: ignoreCache
+                ? undefined
+                : [
+                    'product-listing',
+                    `product-listing-${pageUrl}`,
+                    `product-listing-${pageUrl}-${cultureCode}`,
+                ],
+        },
+        url: `${config.BFF_API_URL}/plp/?pageUrl=${pageUrl}`,
+    });
+    return {
+        ...body,
+        category: body.categories
+            ? {
+                href: body.categories.path,
+                image: {
+                    1: body.categories.smallImagePath,
+                    2: body.categories.smallImagePath,
+                    3: body.categories.smallImagePath,
+                    altText: body.categories.imageAltText,
+                },
+                title: body.categories.shortDescription,
+            }
+            : undefined,
+        promoBanners: body.promoBanners
+            ? {
+                top: body.promoBanners.top || undefined,
+            }
+            : undefined,
+        subcategories: body.categories?.subCategories?.map(subcategory => ({
+            href: subcategory.path,
+            image: {
+                1: subcategory.smallImagePath,
+                2: subcategory.smallImagePath,
+                3: subcategory.smallImagePath,
+                altText: subcategory.imageAltText,
+            },
+            title: subcategory.shortDescription,
+        })),
+    };
+}
+async function fetchNavigationLinks({ cultureCode, headers, ignoreCache, }) {
+    const { body } = await request({
+        headers: { 'Current-Language-Id': cultureCode, ...headers },
+        next: {
+            revalidate: ignoreCache ? 0 : Infinity,
+            tags: ignoreCache
+                ? undefined
+                : ['navigation', `navigation-${cultureCode}`],
+        },
+        url: `${config.BFF_API_URL}/v2/navigation`,
+    });
+    return body;
+}
+async function fetchRecentlyViewedProducts({ cultureCode, }) {
+    const { body } = await request({
+        credentials: 'include',
+        headers: { 'Current-Language-Id': cultureCode },
+        url: `${config.BFF_API_URL}/recently-viewed`,
+    });
+    return body;
+}
+async function patchCart({ cart, forceRecalculation = true, }) {
+    const { body } = await request({
+        body: cart,
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.BFF_API_URL}/api/v1/carts/current${forceRecalculation ? '?forceRecalculation=true' : ''}`,
+    });
+    return body;
+}
+async function placeOrder({ cart, isPending, }) {
+    const newStatus = cart.requiresApproval
+        ? 'AwaitingApproval'
+        : isPending
+            ? 'PendingPaymentValidation'
+            : 'Submitted';
+    const { body } = await request({
+        body: { ...cart, status: newStatus },
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.BFF_API_URL}/api/v1/carts/current?forceRecalculation=false`,
+    });
+    return body;
+}
+async function fetchProductsPrices({ headers, productIds, }) {
+    if (productIds.length === 0)
+        return [];
+    const { body } = await request({
+        body: [...new Set(productIds)],
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        method: 'POST',
+        url: `${config.BFF_API_URL}/api/v1/pricing`,
+    });
+    return body;
+}
+async function saveCartForLater({ cart }) {
+    // USER NEEDS TO BE LOGGED IN
+    const { body } = await request({
+        body: JSON.stringify({ ...cart, status: 'Saved' }),
+        credentials: 'include',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'PATCH',
+        url: `${config.BFF_API_URL}/api/v1/carts/current`,
+    });
+    return body;
+}
+
+export { fetchAnnouncements, fetchNavigationLinks, fetchProductDetailsPageData, fetchProductListingPageData, fetchProductsPrices, fetchRecentlyViewedProducts, patchCart, placeOrder, saveCartForLater };

package/dist/shared/api/shared/hooks/use-awaitable-mutation.d.ts

@@ -0,0 +1,31 @@
+import { QueryClient } from '@tanstack/react-query';
+export type OnError<T extends (...args: any) => Promise<unknown>> = (args: {
+    args: Parameters<T>;
+    error: unknown;
+    queryClient: QueryClient;
+}) => void;
+export type OnSuccess<T extends (...args: any) => Promise<TResult>, TResult = Awaited<ReturnType<T>>> = (args: {
+    args: Parameters<T>;
+    data: TResult;
+    queryClient: QueryClient;
+}) => void;
+export type OnComplete<T extends (...args: any) => Promise<TResult>, TResult = Awaited<ReturnType<T>>> = (args: {
+    args: Parameters<T>;
+    data: TResult | undefined;
+    error: unknown | undefined;
+    queryClient: QueryClient;
+}) => void;
+export interface UseAwaitableMutationArgs<T extends (...args: any) => Promise<TResult>, TResult = Awaited<ReturnType<T>>> {
+    mutationFn: T;
+    onComplete?: OnComplete<T, TResult>;
+    onError?: OnError<T>;
+    onSuccess?: OnSuccess<T, TResult>;
+}
+export declare function useAwaitableMutation<T extends (...args: any) => Promise<TResult>, TResult = Awaited<ReturnType<T>>>({ mutationFn, onComplete, onError, onSuccess, }: UseAwaitableMutationArgs<T, TResult>): {
+    error: unknown;
+    isError: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    mutate: (...args: Parameters<T>) => Promise<TResult>;
+    reset: () => void;
+};

package/dist/shared/api/shared/hooks/use-awaitable-mutation.js

@@ -0,0 +1,47 @@
+"use client";
+import { useState, useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+
+function useAwaitableMutation({ mutationFn, onComplete, onError, onSuccess, }) {
+    const queryClient = useQueryClient();
+    const [isLoading, setIsLoading] = useState(false);
+    const [isSuccess, setIsSuccess] = useState(false);
+    const [error, setError] = useState();
+    const reset = useCallback(() => {
+        setIsLoading(false);
+        setIsSuccess(false);
+        setError(undefined);
+    }, []);
+    const mutate = useCallback(async (...args) => {
+        let result;
+        let error;
+        try {
+            setIsLoading(true);
+            const _result = await mutationFn(...args);
+            result = _result;
+            setIsSuccess(true);
+            onSuccess?.({ args, data: _result, queryClient });
+            return result;
+        }
+        catch (err) {
+            error = err;
+            setError(error);
+            onError?.({ args, error, queryClient });
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+            onComplete?.({ args, data: result, error, queryClient });
+        }
+    }, [mutationFn, onComplete, onError, onSuccess, queryClient]);
+    return {
+        error,
+        isError: Boolean(error),
+        isLoading,
+        isSuccess,
+        mutate,
+        reset,
+    };
+}
+
+export { useAwaitableMutation };

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

@@ -0,0 +1,6 @@
+export interface APIArguments {
+    headers?: {
+        cookie?: string;
+    };
+    ignoreCache?: boolean;
+}

package/dist/shared/api/storefront/hooks/account/use-create-account.d.ts

@@ -0,0 +1,3 @@
+import { AccountModel } from '../../model/storefront.model';
+import { CreateAccountRequestBody } from '../../services/account-service';
+export declare function useCreateAccount(): import("@tanstack/react-query").UseMutationResult<AccountModel, Error, CreateAccountRequestBody, unknown>;

package/dist/shared/api/storefront/hooks/account/use-create-account.js

@@ -0,0 +1,30 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { createAccount } from '../../services/account-service.js';
+import { createSession } from '../../services/authentication-service.js';
+
+function useCreateAccount() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (account) => {
+            try {
+                const body = await createAccount(account);
+                const updatedSession = await createSession({
+                    accessToken: '',
+                    isGuest: false,
+                    password: account.password,
+                    rememberMe: false,
+                    userName: body.userName,
+                });
+                queryClient.setQueriesData({ exact: true, queryKey: ['session'] }, updatedSession);
+                return body;
+            }
+            catch (error) {
+                queryClient.resetQueries();
+                throw error;
+            }
+        },
+    });
+}
+
+export { useCreateAccount };

package/dist/shared/api/storefront/hooks/account/use-create-guest-account.d.ts

@@ -0,0 +1,2 @@
+import { AccountModel } from '../../model/storefront.model';
+export declare function useCreateGuestAccount(): import("@tanstack/react-query").UseMutationResult<AccountModel, Error, void, unknown>;

package/dist/shared/api/storefront/hooks/account/use-create-guest-account.js

@@ -0,0 +1,38 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { createGuestAccount } from '../../services/account-service.js';
+import { fetchSession, createSession } from '../../services/authentication-service.js';
+
+function useCreateGuestAccount() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async () => {
+            try {
+                let session = queryClient.getQueryData(['session']);
+                if (!session) {
+                    session = await fetchSession();
+                    queryClient.setQueryData(['session'], session);
+                }
+                if (!session.pickUpWarehouse) {
+                    throw new Error('No default pick up warehouse found');
+                }
+                const defaultWarehouseId = session.pickUpWarehouse.id;
+                const body = await createGuestAccount({ defaultWarehouseId });
+                await createSession({
+                    accessToken: body.accessToken,
+                    isGuest: true,
+                    password: body.password,
+                    rememberMe: false,
+                    userName: body.userName,
+                });
+                return body;
+            }
+            catch (error) {
+                queryClient.resetQueries();
+                throw error;
+            }
+        },
+    });
+}
+
+export { useCreateGuestAccount };

package/dist/shared/api/storefront/hooks/account/use-fetch-current-account.d.ts

@@ -0,0 +1,3 @@
+export declare function useFetchCurrentAccount({ isEnabled, }?: {
+    isEnabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<import("../../model/storefront.model").AccountModel, Error>;

package/dist/shared/api/storefront/hooks/account/use-fetch-current-account.js

@@ -0,0 +1,13 @@
+"use client";
+import { useQuery } from '@tanstack/react-query';
+import { fetchCurrentAccount } from '../../services/account-service.js';
+
+function useFetchCurrentAccount({ isEnabled = true, } = {}) {
+    return useQuery({
+        enabled: isEnabled,
+        queryFn: fetchCurrentAccount,
+        queryKey: ['account', 'current'],
+    });
+}
+
+export { useFetchCurrentAccount };

package/dist/shared/api/storefront/hooks/account/use-patch-current-account.d.ts

@@ -0,0 +1,11 @@
+import { AccountModel } from '../../model/storefront.model';
+export declare function usePatchCurrentAccount(): {
+    error: unknown;
+    isError: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    mutate: (args_0: {
+        account: Partial<AccountModel>;
+    }) => Promise<AccountModel>;
+    reset: () => void;
+};

package/dist/shared/api/storefront/hooks/account/use-patch-current-account.js

@@ -0,0 +1,20 @@
+"use client";
+import { useQueryClient } from '@tanstack/react-query';
+import { useAwaitableMutation } from '../../../shared/hooks/use-awaitable-mutation.js';
+import { patchCurrentAccount } from '../../services/account-service.js';
+
+function usePatchCurrentAccount() {
+    const queryClient = useQueryClient();
+    return useAwaitableMutation({
+        mutationFn: async ({ account }) => {
+            const updatedAccount = await patchCurrentAccount({ account });
+            /* Completely clear out the client side cache.
+             * By patching the account also the session and
+             * cart are potentially invalid/changed */
+            queryClient.clear();
+            return updatedAccount;
+        },
+    });
+}
+
+export { usePatchCurrentAccount };

package/dist/shared/api/storefront/hooks/authentication/use-fetch-session.d.ts

@@ -1,4 +1,4 @@
-import { SessionModel as ShopSessionModel } from '../../model/shop.model';
+import { SessionModel as ShopSessionModel } from '../../model/storefront.model';
 export declare function useFetchSession({ enabled, }?: {
     enabled?: boolean;
 }): import("@tanstack/react-query").UseQueryResult<ShopSessionModel, Error>;

package/dist/shared/api/storefront/hooks/authentication/use-fetch-session.js

@@ -0,0 +1,20 @@
+"use client";
+import { useQuery } from '@tanstack/react-query';
+import { TIME } from '../../../../utils/time.js';
+import { fetchSession } from '../../services/authentication-service.js';
+
+function useFetchSession({ enabled = true, } = {}) {
+    return useQuery({
+        enabled,
+        gcTime: 15 * TIME.MINUTE,
+        placeholderData: prev => prev,
+        queryFn: async () => {
+            return await fetchSession();
+        },
+        queryKey: ['session'],
+        retry: 3,
+        staleTime: 15 * TIME.MINUTE,
+    });
+}
+
+export { useFetchSession };

package/dist/shared/api/storefront/hooks/authentication/use-invalidate-session.js

@@ -0,0 +1,10 @@
+"use client";
+import { useCallback } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+
+function useInvalidateSession() {
+    const queryClient = useQueryClient();
+    return useCallback(() => queryClient.invalidateQueries({ queryKey: ['session'] }), [queryClient]);
+}
+
+export { useInvalidateSession };

package/dist/shared/api/storefront/hooks/authentication/use-is-authenticated.js

@@ -0,0 +1,9 @@
+"use client";
+import { useFetchSession } from './use-fetch-session.js';
+
+function useIsAuthenticated() {
+    const { data } = useFetchSession();
+    return data?.isAuthenticated;
+}
+
+export { useIsAuthenticated };

package/dist/shared/api/storefront/hooks/authentication/use-patch-session.d.ts

@@ -0,0 +1,22 @@
+export declare function usePatchSession(): {
+    error: unknown;
+    isError: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    mutate: (args_0: {
+        session: Partial<Omit<import("../../model/storefront.model").SessionModel, "billTo" | "shipTo" | "language"> & {
+            billTo?: import("../../model/storefront.model").BillToModel | {
+                id: string;
+            } | null;
+            billToId?: string | null;
+            language?: import("../../model/storefront.model").LanguageModel | {
+                id: string;
+            } | null;
+            shipTo?: import("../../model/storefront.model").ShipToModel | {
+                id: string;
+            } | null;
+            shipToId?: string | null;
+        }>;
+    }) => Promise<import("../../model/storefront.model").SessionModel>;
+    reset: () => void;
+};

package/dist/shared/api/storefront/hooks/authentication/use-patch-session.js

@@ -0,0 +1,17 @@
+"use client";
+import { useQueryClient } from '@tanstack/react-query';
+import { useAwaitableMutation } from '../../../shared/hooks/use-awaitable-mutation.js';
+import { patchSession } from '../../services/authentication-service.js';
+
+function usePatchSession() {
+    const queryClient = useQueryClient();
+    return useAwaitableMutation({
+        mutationFn: async ({ session }) => {
+            const updatedSession = await patchSession({ session });
+            queryClient.clear();
+            return updatedSession;
+        },
+    });
+}
+
+export { usePatchSession };

package/dist/shared/api/storefront/hooks/authentication/use-recover-password.d.ts

@@ -0,0 +1,4 @@
+import { SessionModel } from '../../model/storefront.model';
+export declare function useRecoverPassword(): import("@tanstack/react-query").UseMutationResult<SessionModel, Error, {
+    userName: string;
+}, unknown>;

package/dist/shared/api/storefront/hooks/authentication/use-recover-password.js

@@ -0,0 +1,16 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { recoverPassword } from '../../services/authentication-service.js';
+
+function useRecoverPassword() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ userName }) => {
+            const session = await recoverPassword({ userName });
+            queryClient.setQueryData(['session'], session);
+            return session;
+        },
+    });
+}
+
+export { useRecoverPassword };

package/dist/shared/api/storefront/hooks/authentication/use-sign-in.d.ts

@@ -1,5 +1,6 @@
 import { AuthenticationResponse } from '../../services/authentication-service';
 export declare function useSignIn(): import("@tanstack/react-query").UseMutationResult<AuthenticationResponse, Error, {
     password: string;
+    rememberMe: boolean;
     userName: string;
 }, unknown>;

package/dist/shared/api/storefront/hooks/authentication/use-sign-in.js

@@ -0,0 +1,33 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { UnprocessableContentRequestError } from '../../../../fetch/request.js';
+import { signIn, createSession, InvalidGrantError } from '../../services/authentication-service.js';
+
+function useSignIn() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ password, rememberMe, userName }) => {
+            try {
+                const body = await signIn({ password, userName });
+                await createSession({
+                    accessToken: body.access_token,
+                    isGuest: false,
+                    password,
+                    rememberMe,
+                    userName,
+                });
+                return body;
+            }
+            catch (error) {
+                if (error instanceof UnprocessableContentRequestError)
+                    throw error;
+                if (error instanceof InvalidGrantError)
+                    throw error;
+                queryClient.resetQueries();
+                throw error;
+            }
+        },
+    });
+}
+
+export { useSignIn };

package/dist/shared/api/storefront/hooks/authentication/use-sign-out-mutation.d.ts

@@ -0,0 +1,9 @@
+type SignOutVariables = {
+    returnUrl?: string;
+} | void;
+export interface UseSignOutArgs {
+    onError?: (error: Error) => void;
+    onSuccess?: (data: void, variables: SignOutVariables) => void;
+}
+export declare function useSignOutMutation(options?: UseSignOutArgs): import("@tanstack/react-query").UseMutationResult<void, Error, SignOutVariables, unknown>;
+export {};

package/dist/shared/api/storefront/hooks/authentication/use-sign-out-mutation.js

@@ -0,0 +1,26 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { UnauthorizedRequestError } from '../../../../fetch/request.js';
+import { signOut } from '../../services/authentication-service.js';
+
+function useSignOutMutation(options = {}) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        ...options,
+        mutationFn: async (_args) => {
+            try {
+                await signOut();
+            }
+            catch (error) {
+                if (error instanceof UnauthorizedRequestError)
+                    return;
+                throw error;
+            }
+            finally {
+                queryClient.resetQueries();
+            }
+        },
+    });
+}
+
+export { useSignOutMutation };

package/dist/shared/api/storefront/hooks/authentication/use-sign-out.d.ts

@@ -1 +1,5 @@
-export declare function useSignOut(): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+export declare function useSignOut(options?: {
+    onSignOut?: VoidFunction;
+}): import("@tanstack/react-query").UseMutateFunction<void, Error, void | {
+    returnUrl?: string;
+}, unknown>;

package/dist/shared/api/storefront/hooks/authentication/use-sign-out.js

@@ -0,0 +1,30 @@
+"use client";
+import Cookies from 'js-cookie';
+import { logger } from '../../../../../logging/logger.js';
+import { useNavigate } from '../../../../routing/use-navigate.js';
+import { usePaths } from '../../../../routing/use-paths.js';
+import { useSignOutMutation } from './use-sign-out-mutation.js';
+
+function useSignOut(options = {}) {
+    const { navigate } = useNavigate();
+    const paths = usePaths();
+    const { mutate } = useSignOutMutation({
+        onError: logger.error,
+        onSuccess: (_data, variables) => {
+            // TODO: Remove when Spire is deprecated
+            Cookies.remove('NavigationMode');
+            // Removing certain cookies in case the session doesn't do this
+            // This is, however, following user action; in case the server cancels authentication, this does not get run
+            Cookies.remove('CurrentBillToId');
+            Cookies.remove('CurrentShipToId');
+            Cookies.remove('BillToIdShipToId');
+            navigate((variables && variables.returnUrl) || paths.HOME, {
+                reload: true,
+            });
+            options.onSignOut?.();
+        },
+    });
+    return mutate;
+}
+
+export { useSignOut };

package/dist/shared/api/storefront/hooks/cart/use-add-bulk-products-to-current-cart.d.ts

@@ -0,0 +1,4 @@
+import { useMutation } from '@tanstack/react-query';
+import { CartLineModel } from '../../model/storefront.model';
+import { AddBulkProductsToCurrentCartParams } from '../../services/cart-service';
+export declare function useAddBulkProductsToCurrentCart(options?: Parameters<typeof useMutation<CartLineModel[], Error, AddBulkProductsToCurrentCartParams>>[0]): import("@tanstack/react-query").UseMutationResult<CartLineModel[], Error, AddBulkProductsToCurrentCartParams, unknown>;

package/dist/shared/api/storefront/hooks/cart/use-add-bulk-products-to-current-cart.js

@@ -0,0 +1,21 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { addBulkProductsToCurrentCart } from '../../services/cart-service.js';
+
+function useAddBulkProductsToCurrentCart(options) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (params) => {
+            const result = await addBulkProductsToCurrentCart(params);
+            queryClient.invalidateQueries({ queryKey: ['carts', 'current'] });
+            return result;
+        },
+        onError: (error, variables, context) => {
+            queryClient.invalidateQueries({ queryKey: ['carts', 'current'] });
+            options?.onError?.(error, variables, context);
+        },
+        ...options,
+    });
+}
+
+export { useAddBulkProductsToCurrentCart };