@sonic-equipment/ui 0.0.119 → 1.1.0

package/dist/shared/api/storefront/hooks/wishlist/use-delete-wishlist-item-from-wishlist.js

@@ -0,0 +1,19 @@
+"use client";
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { deleteWishListItemFromWishList } from '../../services/wishlist-service.js';
+
+function useDeleteWishListItemFromWishList() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ wishListId, wishListItemId }) => {
+            await deleteWishListItemFromWishList({ wishListId, wishListItemId });
+        },
+        onSettled() {
+            queryClient.invalidateQueries({
+                queryKey: ['wishlists', 'wishlistlines'],
+            });
+        },
+    });
+}
+
+export { useDeleteWishListItemFromWishList };

package/dist/shared/api/storefront/hooks/wishlist/use-fetch-all-wishlists-items.d.ts

@@ -1,4 +1,4 @@
-import { WishListLines } from '../../model/shop.model';
+import { WishListLines } from '../../model/storefront.model';
 interface UseFetchAllWishListsItemsArgs {
     enabled?: boolean;
 }

package/dist/shared/api/storefront/hooks/wishlist/use-fetch-all-wishlists-items.js

@@ -0,0 +1,26 @@
+"use client";
+import { useQueryClient, useQuery } from '@tanstack/react-query';
+import { TIME } from '../../../../utils/time.js';
+import { fetchAllWishListsItems } from '../../services/wishlist-service.js';
+
+function useFetchAllWishListsItems({ enabled = true } = { enabled: true }) {
+    const queryClient = useQueryClient();
+    return useQuery({
+        enabled,
+        gcTime: 15 * TIME.MINUTE,
+        placeholderData: prev => prev,
+        queryFn: async () => {
+            let wishLists = queryClient.getQueryData(['wishlists']);
+            const results = await fetchAllWishListsItems(wishLists && { wishListCollection: wishLists });
+            if (wishLists && wishLists.length > 0)
+                return results;
+            wishLists = Object.values(results.reduce((map, { wishList }) => ({ ...map, [wishList.id]: wishList }), {}));
+            queryClient.setQueryData(['wishlists'], wishLists);
+            return results;
+        },
+        queryKey: ['wishlists', 'wishlistlines'],
+        staleTime: 15 * TIME.MINUTE,
+    });
+}
+
+export { useFetchAllWishListsItems };

package/dist/shared/api/storefront/hooks/wishlist/use-fetch-wishlists.d.ts

@@ -1,2 +1,2 @@
-import { WishListCollectionModel as ShopWishListCollectionModel } from '../../model/shop.model';
+import { WishListCollectionModel as ShopWishListCollectionModel } from '../../model/storefront.model';
 export declare function useFetchWishLists(): import("@tanstack/react-query").UseQueryResult<ShopWishListCollectionModel, Error>;

package/dist/shared/api/storefront/hooks/wishlist/use-fetch-wishlists.js

@@ -0,0 +1,15 @@
+"use client";
+import { useQuery } from '@tanstack/react-query';
+import { TIME } from '../../../../utils/time.js';
+import { getWishLists } from '../../services/wishlist-service.js';
+
+function useFetchWishLists() {
+    return useQuery({
+        gcTime: 15 * TIME.MINUTE,
+        queryFn: getWishLists,
+        queryKey: ['wishlists'],
+        staleTime: 15 * TIME.MINUTE,
+    });
+}
+
+export { useFetchWishLists };

package/dist/shared/api/storefront/model/{shop.model.d.ts → storefront.model.d.ts}

@@ -1,3 +1,5 @@
+import { JSX } from 'react';
+import { CurrencyCode } from '../../../../intl/types';
 export interface BaseModel {
     properties: {
         [key: string]: string;
@@ -127,7 +129,7 @@ export interface SessionModel extends BaseModel {
     dashboardIsHomepage: boolean | null;
     deviceType: string;
     displayChangeCustomerLink: boolean;
-    displayMyAccountMenu: boolean;
+    displayMySonicMenu: boolean;
     displayPricingAndInventory: boolean;
     email: string;
     firstName: string;
@@ -157,14 +159,23 @@ export interface SessionModel extends BaseModel {
     userRoles: string;
     userRolesTranslated: string;
 }
-export type PatchSessionModel = Partial<Omit<SessionModel, 'billTo' | 'shipTo'> & {
+export type PatchSessionModel = Partial<Omit<SessionModel, 'billTo' | 'shipTo' | 'language'> & {
     billTo?: BillToModel | {
         id: string;
     } | null;
+    billToId?: string | null;
+    language?: LanguageModel | {
+        id: string;
+    } | null;
     shipTo?: ShipToModel | {
         id: string;
     } | null;
+    shipToId?: string | null;
 }>;
+export interface SpirePageModel {
+    redirectTo: string | null;
+    statusCode: number;
+}
 export interface ShipToModel extends BaseModel {
     address1: string;
     address2: string;
@@ -861,6 +872,10 @@ export interface CartLineModel extends BaseModel {
     productName: string;
     productSubscription: ProductSubscriptionDto | null;
     productUri: string;
+    properties: {
+        [key: string]: string;
+        totalListPrice: string;
+    };
     qtyLeft: number;
     qtyOnHand: number;
     qtyOrdered: number | null;
@@ -929,6 +944,10 @@ export interface CartModel extends BaseModel {
     paymentOptions?: PaymentOptionsDto | null;
     poNumber: string;
     promotionCode: string;
+    properties: {
+        customerVatNumberStatus?: 'valid' | 'invalid' | 'failure';
+        industry?: string;
+    };
     quoteRequiredCount: number;
     requestedDeliveryDate: string;
     requestedDeliveryDateDisplay: Date | null;
@@ -966,11 +985,35 @@ export interface CartModel extends BaseModel {
     vmiLocationId?: string | null;
     warehouses: WarehouseDto[] | null;
 }
-export type PatchCartModel = Partial<Omit<CartModel, 'billTo'> & {
-    billTo?: BillToModel | {
+export type PatchBillToModel = Partial<Omit<BillToModel, 'country'> & {
+    country?: CountryModel | {
+        id: string;
+    } | null;
+}> & {
+    id: string;
+};
+export type PostShipToModel = Partial<Omit<ShipToModel, 'country'> & {
+    country?: CountryModel | {
         id: string;
     } | null;
 }>;
+export type PatchShipToModel = Partial<Omit<ShipToModel, 'country'> & {
+    country?: CountryModel | {
+        id: string;
+    } | null;
+}> & {
+    id: string;
+};
+export type PatchCartModel = Partial<Omit<Omit<CartModel, 'billTo'>, 'shipTo'> & {
+    billTo?: PatchBillToModel | {
+        id: string;
+    } | null;
+    shipTo?: PatchShipToModel | {
+        id: string;
+    } | null;
+}> & {
+    id: string;
+};
 export interface WarehouseDto {
     address1: string;
     address2: string;
@@ -2158,6 +2201,10 @@ export interface MobilePageDto {
         [key: string]: any;
     } | null;
 }
+export interface AddressesCollectionModel extends BaseModel {
+    pagination: PaginationModel | null;
+    shipTos: ShipToModel[] | null;
+}
 export interface OrderCollectionModel extends BaseModel {
     orders: OrderModel[] | null;
     pagination: PaginationModel | null;
@@ -2183,7 +2230,7 @@ export interface OrderModel extends BaseModel {
     btCountry: string;
     canAddAllToCart: boolean;
     canAddToCart: boolean;
-    currencyCode: string;
+    currencyCode: CurrencyCode;
     currencySymbol: string;
     customerNumber: string;
     customerPO: string;
@@ -2235,7 +2282,7 @@ export interface OrderModel extends BaseModel {
     stAddress4: string;
     stCompanyName: string;
     stCountry: string;
-    status: string;
+    status: OrderStatus;
     statusDisplay: string;
     taxAmount: number;
     taxAmountDisplay: string;
@@ -3018,3 +3065,50 @@ export interface PaymentAuthenticationModel {
     transactionId: string;
     webOrderNumber: string;
 }
+export interface PaymetricResponseApiResult {
+    creditCard: CreditCardDto;
+    message: string;
+    success: boolean;
+}
+export type AdyenResultCode = 'AuthenticationFinished' | 'AuthenticationNotRequired' | 'Authorised' | 'Cancelled' | 'ChallengeShopper' | 'Error' | 'IdentifyShopper' | 'PartiallyAuthorised' | 'Pending' | 'PresentToShopper' | 'Received' | 'RedirectShopper' | 'Refused';
+export interface AdyenPaymentModel {
+    action?: any;
+    amount: {
+        currency: string;
+        value: number | null;
+    } | null;
+    merchantReference: string;
+    paymentMethod: string;
+    pspReference: string;
+    resultCode: AdyenResultCode;
+}
+export interface Language {
+    cultureCode: string;
+    description: string;
+    id: string;
+    languageCode: string;
+}
+export interface Country {
+    abbreviation: string;
+    currencyCode: string;
+    id: string;
+    languages: Language[];
+    name: string;
+}
+export declare const orderStatusMappings: {
+    readonly Cancelled: ["Cancelled"];
+    readonly ForwardToReseller: ["ForwardToReseller"];
+    readonly Fulfilled: ["FullyDelivered"];
+    readonly 'Partially fulfilled': ["PartiallyDelivered"];
+    readonly Processing: ["Edited", "ProcessingInWarehouse", "ResubmittedToWarehouse", "SendToWarehouse", "Submitted"];
+    readonly Saved: ["Saved"];
+    readonly 'Waiting for customer service': ["ErrorSendingToWarehouse", "PendingPaymentValidation", "OnHold", "PendingManualVatValidation"];
+};
+export type OrderStatus = keyof typeof orderStatusMappings;
+export declare const orderStatuses: OrderStatus[];
+export declare function fromApiStatusToOrderStatus(status: string): OrderStatus;
+export declare const isValidStatus: (status: string | undefined | null) => status is OrderStatus;
+export interface SortOption {
+    name: string;
+    order: 'ASC' | 'DESC';
+}

package/dist/shared/api/storefront/model/storefront.model.js

@@ -0,0 +1,74 @@
+import { logger } from '../../../../logging/logger.js';
+
+var CurrencyPositioningType;
+(function (CurrencyPositioningType) {
+    CurrencyPositioningType["Left"] = "Left";
+    CurrencyPositioningType["Right"] = "Right";
+})(CurrencyPositioningType || (CurrencyPositioningType = {}));
+var AvailabilityMessageType;
+(function (AvailabilityMessageType) {
+    AvailabilityMessageType[AvailabilityMessageType["NoMessage"] = 0] = "NoMessage";
+    AvailabilityMessageType[AvailabilityMessageType["Available"] = 1] = "Available";
+    AvailabilityMessageType[AvailabilityMessageType["OutOfStock"] = 2] = "OutOfStock";
+    AvailabilityMessageType[AvailabilityMessageType["LowStock"] = 3] = "LowStock";
+})(AvailabilityMessageType || (AvailabilityMessageType = {}));
+var VariantDisplayTypeValues;
+(function (VariantDisplayTypeValues) {
+    VariantDisplayTypeValues["Button"] = "Button";
+    VariantDisplayTypeValues["Dropdown"] = "Dropdown";
+    VariantDisplayTypeValues["SwatchDropdown"] = "SwatchDropdown";
+    VariantDisplayTypeValues["SwatchGrid"] = "SwatchGrid";
+    VariantDisplayTypeValues["SwatchList"] = "SwatchList";
+})(VariantDisplayTypeValues || (VariantDisplayTypeValues = {}));
+var BadgeTypeValues;
+(function (BadgeTypeValues) {
+    BadgeTypeValues["Image"] = "Image";
+    BadgeTypeValues["Text"] = "Text";
+})(BadgeTypeValues || (BadgeTypeValues = {}));
+var BadgeImagePlacementValues;
+(function (BadgeImagePlacementValues) {
+    BadgeImagePlacementValues["BottomCenter"] = "Bottom Center";
+    BadgeImagePlacementValues["BottomLeft"] = "Bottom Left";
+    BadgeImagePlacementValues["BottomRight"] = "Bottom Right";
+    BadgeImagePlacementValues["None"] = "None";
+    BadgeImagePlacementValues["TopCenter"] = "Top Center";
+    BadgeImagePlacementValues["TopLeft"] = "Top Left";
+    BadgeImagePlacementValues["TopRight"] = "Top Right";
+})(BadgeImagePlacementValues || (BadgeImagePlacementValues = {}));
+var BadgeStyleValues;
+(function (BadgeStyleValues) {
+    BadgeStyleValues["Rectangle"] = "Rectangle";
+    BadgeStyleValues["Round"] = "Round";
+})(BadgeStyleValues || (BadgeStyleValues = {}));
+const orderStatusMappings = {
+    Cancelled: ['Cancelled'],
+    ForwardToReseller: ['ForwardToReseller'],
+    Fulfilled: ['FullyDelivered'],
+    'Partially fulfilled': ['PartiallyDelivered'],
+    Processing: [
+        'Edited',
+        'ProcessingInWarehouse',
+        'ResubmittedToWarehouse',
+        'SendToWarehouse',
+        'Submitted',
+    ],
+    Saved: ['Saved'],
+    'Waiting for customer service': [
+        'ErrorSendingToWarehouse',
+        'PendingPaymentValidation',
+        'OnHold',
+        'PendingManualVatValidation',
+    ],
+};
+const orderStatuses = Object.keys(orderStatusMappings);
+function fromApiStatusToOrderStatus(status) {
+    for (const orderStatus of orderStatuses) {
+        if (orderStatusMappings[orderStatus].includes(status))
+            return orderStatus;
+    }
+    logger.error(`Unknown order status from API '${status}'`);
+    return 'Waiting for customer service';
+}
+const isValidStatus = (status) => Object.keys(orderStatusMappings).includes(status || '');
+
+export { AvailabilityMessageType, BadgeImagePlacementValues, BadgeStyleValues, BadgeTypeValues, CurrencyPositioningType, VariantDisplayTypeValues, fromApiStatusToOrderStatus, isValidStatus, orderStatusMappings, orderStatuses };

package/dist/shared/api/storefront/services/account-service.d.ts

@@ -0,0 +1,31 @@
+import { BadRequestError } from '../../../fetch/request';
+import { AccountModel } from '../model/storefront.model';
+export declare function fetchCurrentAccount(): Promise<AccountModel>;
+export declare class ExistingAccountError extends BadRequestError {
+    constructor(error: Error);
+}
+export interface CreateAccountRequestBase {
+    email: string;
+    firstName?: string;
+    isSubscribed: boolean;
+    lastName: string;
+    password: string;
+}
+export interface CreatePrivateAccountRequestBody extends CreateAccountRequestBase {
+    companyName?: string | undefined;
+    countryCode: string;
+    isPrivateAccount: true;
+}
+export interface CreateBusinessAccountRequestBody extends CreateAccountRequestBase {
+    companyName: string;
+    countryCode: string;
+    isPrivateAccount: false;
+}
+export type CreateAccountRequestBody = CreatePrivateAccountRequestBody | CreateBusinessAccountRequestBody;
+export declare function createAccount({ companyName, countryCode, email, firstName, isPrivateAccount, isSubscribed, lastName, password, }: CreateAccountRequestBody): Promise<AccountModel>;
+export declare function createGuestAccount({ defaultWarehouseId, }: {
+    defaultWarehouseId: string;
+}): Promise<AccountModel>;
+export declare function patchCurrentAccount({ account, }: {
+    account: Partial<AccountModel>;
+}): Promise<AccountModel>;

package/dist/shared/api/storefront/services/account-service.js

@@ -0,0 +1,87 @@
+import { config } from '../../../../config.js';
+import { request, BadRequestError } from '../../../fetch/request.js';
+
+async function fetchCurrentAccount() {
+    const { body } = await request({
+        url: `${config.SHOP_API_URL}/api/v1/accounts/current`,
+    });
+    return body;
+}
+class ExistingAccountError extends BadRequestError {
+    constructor(error) {
+        super(error);
+        this.name = 'ExistingAccountError';
+    }
+}
+async function createAccount({ companyName, countryCode, email, firstName, isPrivateAccount, isSubscribed, lastName, password, }) {
+    try {
+        const { body } = await request({
+            body: {
+                email,
+                firstName,
+                isSubscribed,
+                lastName,
+                password,
+                properties: {
+                    PrivateAccount: isPrivateAccount,
+                    companyName,
+                    countryCode,
+                },
+                userName: '',
+            },
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+            url: `${config.SHOP_API_URL}/api/v1/accounts`,
+        });
+        return body;
+    }
+    catch (error) {
+        if (error instanceof BadRequestError &&
+            error.body?.message === 'Email Address already exists')
+            throw new ExistingAccountError(error);
+        throw error;
+    }
+}
+async function createGuestAccount({ defaultWarehouseId, }) {
+    const { body } = await request({
+        body: {
+            defaultFulfillmentMethod: 'Ship',
+            defaultWarehouseId,
+            isGuest: true,
+        },
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        url: `${config.SHOP_API_URL}/api/v1/accounts`,
+    });
+    return body;
+}
+async function patchCurrentAccount({ account, }) {
+    try {
+        const { body } = await request({
+            body: account,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'PATCH',
+            url: `${config.SHOP_API_URL}/api/v1/accounts/current`,
+        });
+        return body;
+    }
+    catch (error) {
+        if (error instanceof BadRequestError &&
+            error.body?.message === 'Email Address already exists')
+            throw new ExistingAccountError(error);
+        throw error;
+    }
+}
+/*
+  "setDefaultCustomer": true,
+  "defaultCustomerId": "f73fd87f-bf14-4454-afaf-b328007d3c86",
+  "defaultFulfillmentMethod": "Ship",
+*/
+
+export { ExistingAccountError, createAccount, createGuestAccount, fetchCurrentAccount, patchCurrentAccount };

package/dist/shared/api/storefront/services/authentication-service.d.ts

@@ -1,31 +1,55 @@
-import { AccountModel, PatchSessionModel, SessionModel, SessionModel as ShopSessionModel } from '../model/shop.model';
-export declare function fetchSession(): Promise<ShopSessionModel>;
+import { BadRequestError, RequestError, RequestReturnType } from '../../../fetch/request';
+import { APIArguments } from '../../shared/types';
+import { PatchSessionModel, SessionModel } from '../model/storefront.model';
+export declare function fetchSession(args?: APIArguments): Promise<SessionModel>;
+export declare class InvalidPasswordError extends BadRequestError {
+    constructor(error: RequestError);
+}
+export declare class NonUniquePasswordError extends BadRequestError {
+    constructor(error: RequestError);
+}
+export declare class UserNotFoundError extends BadRequestError {
+    constructor(error: RequestError);
+}
+export declare class UnableToChangePasswordError extends BadRequestError {
+    constructor(error: RequestError);
+}
+export declare class InvalidGrantError extends BadRequestError {
+    constructor(error: RequestError);
+}
+export declare class InvalidEmailPasswordCombinationError extends InvalidGrantError {
+    constructor(error: RequestError);
+}
+export declare class AccountLockedOutError extends InvalidGrantError {
+    constructor(error: RequestError);
+}
 export declare function patchSession({ session, }: {
     session: PatchSessionModel;
-}): Promise<ShopSessionModel>;
+}): Promise<SessionModel>;
 export interface AuthenticationResponse {
     access_token: string;
     error_description: string;
     expires_in: number;
     refresh_token: string;
 }
-export declare function signIn({ password, userName, }: {
+export type SignInScope = 'iscapi' | 'isc_admin_api' | 'offline_access';
+export declare function signIn({ password, scope, userName, }: {
     password: string;
+    scope?: SignInScope[];
     userName: string;
 }): Promise<AuthenticationResponse>;
 export interface CreateSessionRequestBody {
-    isGuest?: boolean | undefined;
-    password?: string | undefined;
-    rememberMe?: boolean | undefined;
+    isGuest: boolean;
+    keepMeSignedIn?: boolean;
+    password: string | undefined;
+    rememberMe: boolean | undefined;
     returnUrl?: string | undefined;
     userName: string;
 }
-export declare function createSession({ accessToken, password, userName, }: {
+export declare function createSession({ accessToken, isGuest, keepMeSignedIn, password, rememberMe, returnUrl, userName, }: {
     accessToken: string;
-    password: string;
+} & CreateSessionRequestBody): Promise<SessionModel>;
+export declare function signOut(args?: APIArguments): Promise<RequestReturnType<unknown>>;
+export declare function recoverPassword({ userName, }: {
     userName: string;
 }): Promise<SessionModel>;
-export declare function signOut(): Promise<void>;
-export declare function createGuestAccount({ defaultWarehouseId, }: {
-    defaultWarehouseId: string;
-}): Promise<AccountModel>;