@sonic-equipment/ui 183.0.0 → 185.0.0

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

@@ -0,0 +1,84 @@
+import { config } from '../../../../config.js';
+import { request, RequestError, isRequestError } 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 RequestError {
+    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 (isRequestError(error) &&
+            error.status === 400 &&
+            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 (isRequestError(error) &&
+            error.status === 400 &&
+            error.body?.message === 'Email Address already exists')
+            throw new ExistingAccountError(error);
+        throw error;
+    }
+}
+
+export { ExistingAccountError, createAccount, createGuestAccount, fetchCurrentAccount, patchCurrentAccount };

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

@@ -1,6 +1,12 @@
 import { RequestError } from '../../../fetch/request';
-import { AccountModel, PatchSessionModel, SessionModel } from '../model/storefront.model';
+import { PatchSessionModel, SessionModel } from '../model/storefront.model';
 export declare function fetchSession(): Promise<SessionModel>;
+export declare class InvalidPasswordError extends Error {
+    constructor(error: RequestError);
+}
+export declare class NonUniquePasswordError extends Error {
+    constructor(error: RequestError);
+}
 export declare function patchSession({ session, }: {
     session: PatchSessionModel;
 }): Promise<SessionModel>;
@@ -26,31 +32,6 @@ export declare function createSession({ accessToken, isGuest, keepMeSignedIn, pa
     accessToken: string;
 } & CreateSessionRequestBody): Promise<SessionModel>;
 export declare function signOut(): Promise<void>;
-export declare function createGuestAccount({ defaultWarehouseId, }: {
-    defaultWarehouseId: string;
-}): Promise<AccountModel>;
 export declare function recoverPassword({ userName, }: {
     userName: string;
 }): Promise<SessionModel>;
-export declare class ExistingAccountError extends RequestError {
-    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>;

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

@@ -1,5 +1,5 @@
 import { config } from '../../../../config.js';
-import { request, isRequestError, RequestError } from '../../../fetch/request.js';
+import { request, isRequestError } from '../../../fetch/request.js';
 
 async function fetchSession() {
     const { body } = await request({
@@ -8,17 +8,43 @@ async function fetchSession() {
     });
     return body;
 }
+class InvalidPasswordError extends Error {
+    constructor(error) {
+        super(error.body?.message || error.message);
+        this.name = 'InvalidPasswordError';
+    }
+}
+class NonUniquePasswordError extends Error {
+    constructor(error) {
+        super(error.body?.message || error.message);
+        this.name = 'NonUniquePasswordError';
+    }
+}
 async function patchSession({ session, }) {
-    const { body } = await request({
-        body: session,
-        credentials: 'include',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        method: 'PATCH',
-        url: `${config.SHOP_API_URL}/api/v1/sessions/current`,
-    });
-    return body;
+    try {
+        const { body } = await request({
+            body: session,
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'PATCH',
+            url: `${config.SHOP_API_URL}/api/v1/sessions/current`,
+        });
+        return body;
+    }
+    catch (error) {
+        if (isRequestError(error) && error.status === 400) {
+            if (error.body?.message ===
+                'New Password is required and must be different than Current Password') {
+                throw new NonUniquePasswordError(error);
+            }
+            if (error.body?.message === 'Current Password is invalid') {
+                throw new InvalidPasswordError(error);
+            }
+        }
+        throw error;
+    }
 }
 async function signIn({ password, userName, }) {
     const params = new URLSearchParams();
@@ -70,21 +96,6 @@ async function signOut() {
         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 recoverPassword({ userName, }) {
     const { body } = await request({
         body: {
@@ -99,43 +110,5 @@ async function recoverPassword({ userName, }) {
     });
     return body;
 }
-class ExistingAccountError extends RequestError {
-    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 (isRequestError(error) &&
-            error.status === 400 &&
-            error.body?.message === 'Email Address already exists')
-            throw new ExistingAccountError(error);
-        throw error;
-    }
-}
 
-export { ExistingAccountError, createAccount, createGuestAccount, createSession, fetchSession, patchSession, recoverPassword, signIn, signOut };
+export { InvalidPasswordError, NonUniquePasswordError, createSession, fetchSession, patchSession, recoverPassword, signIn, signOut };

package/dist/shared/hooks/use-watch-css-property.js

@@ -3,7 +3,15 @@ import { useState, useEffect } from 'react';
 import { getCssPropertyValue } from '../utils/css.js';
 
 function useWatchCssProperty(property) {
-    const [value, setValue] = useState(() => getCssPropertyValue(property));
+    const [value, setValue] = useState(() => {
+        try {
+            return getCssPropertyValue(property);
+        }
+        catch {
+            // If the property can not be retrieved, return undefined
+            return;
+        }
+    });
     useEffect(() => {
         if (typeof MutationObserver === 'undefined' ||
             typeof document === 'undefined')