@nuskin/ns-shop 5.14.1 → 5.14.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "5.14.1",
+  "version": "5.14.3",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {

package/src/cart/cart.js

@@ -58,6 +58,7 @@ export default function Cart(cartData) {
 
     let cntryCd = '';
     let userId = '';
+    let type = 'market';
     let scanCards = [];
     let signupInfo = {
         checkForSignup: true,
@@ -94,6 +95,7 @@ export default function Cart(cartData) {
             "version": version,
             "userId": userId,
             "cntryCd": cntryCd,
+            "type": type,
             "summerPromo": summerPromo,
             "payForShippingWithPoints": payForShippingWithPoints,
             "isGift": isGift,
@@ -496,7 +498,7 @@ export default function Cart(cartData) {
      */
     this.removeItems = function(options) {
         if (options.all) {
-            removeAllItems();
+            removeAllItems(options);
         } else {
             if (options.cartItems || options.cartOrderItems || options.cartAdrItems) {
                 removeCartItems(options);
@@ -902,11 +904,11 @@ export default function Cart(cartData) {
     }
 
     // Clears the whole cart
-    function removeAllItems() {
+    function removeAllItems(options) {
         itemTable.clear();
         trimScanCards(0);
         updateCartTotals();
-        publish(events.shop.CART_UPDATED, {removeAll: true});
+        publish(events.shop.CART_UPDATED, {removeAll: true, removeCart: options.removeCart === true});
     }
 
     /**
@@ -914,16 +916,12 @@ export default function Cart(cartData) {
      * @param options
      */
     function removeCartItems(options) {
-        const updateInfo = {};
+        const updateInfo = {removeCart: options.removeCart === true};
         const items = getCartItems(options);
-        const allCartItems = getAllCartItems();
 
-        if (allCartItems.length > items.length) {
-            updateInfo.removeItems = true;
-            updateInfo.removeItemInfo = items.map((item) => ({id: item.id, qty: item.qty}));
-        } else {
-            updateInfo.removeAll = true;
-        }
+        updateInfo.removeItems = {
+            items: items.map((item) => ({id: item.id, qty: item.qty}))
+        };
 
         removeItemsFromItemTable(items);
         if (options.cartItems || options.cartAdrItems) {
@@ -1302,6 +1300,7 @@ export default function Cart(cartData) {
                 }
                 json.pcId = id;
                 json.pcVersion = version;
+                json.pcType = type;
             }
             events.publish(event, json);
         }
@@ -1368,6 +1367,7 @@ export default function Cart(cartData) {
         return {
             id: id,
             version: version,
+            type: type,
             qty: scope.getItemCnt(options),
             totalOrderPrice: totalOrderPrice,
             totalAdrPrice: totalAdrPrice,
@@ -1489,6 +1489,9 @@ export default function Cart(cartData) {
             cntryCd = cartData.cntryCd;
             currencyCode = CurrencyService.getCurrency(cntryCd).currencyCode;
         }
+        if (cartData.type) {
+            type = cartData.type;
+        }
         if (cartData.userId) {
             userId = cartData.userId;
         }
@@ -1582,6 +1585,14 @@ export default function Cart(cartData) {
                 version = _version;
             }
         },
+        type: {
+            get: function() {
+                return type;
+            },
+            set: function(_type) {
+                type = _type;
+            }
+        },
         payForShippingWithPoints: {
             get: function() {
                 return payForShippingWithPoints;

package/src/cart/cartService.js

@@ -144,7 +144,7 @@ function setCart(cart, updateTimestamp = true) {
             cart.timestamp = updateTimestamp ? Date.now() : cart.timestamp;
             storage.setItem({...CART_STORAGE_KEY, key: _getCartStorageName(cart.cntryCd)}, cart);
         } else {
-            cart = new Cart({cntryCd: RunConfigService.getRunConfig().country, userId: ''});
+            cart = new Cart({cntryCd: RunConfigService.getRunConfig().country, userId: '', type: _cart_.type});
             storage.setItem({...CART_STORAGE_KEY, key: _getCartStorageName(cart.cntryCd)}, cart);
         }
     }

package/src/cart/persistentCartService.js

@@ -6,8 +6,6 @@ import {get, forEach} from 'lodash';
 import axios from 'axios';
 
 const ADD = 'add';
-const REMOVE = 'remove';
-const REMOVE_CART = 'remove-cart';
 const MERGE_PERSISTED_CART= 'merge persisted cart';
 
 let timerId = null;
@@ -24,28 +22,42 @@ class PcActions {
 
         this.pcId = this.q.length > 0 ? this.q[0].pcId : 0;
         this.pcVersion = this.q.length > 0 ? this.q[0].pcVersion : 0;
+        this.pcType = this.q.length > 0 ? this.q[0].pcType : 0;
     }
 
     hasItems() {
         return this.q.length > 0;
     }
 
-    hasRemoveAllItem() {
+    hasRemoveCartItem() {
         let retVal = false;
 
         this.q.forEach((action) => {
-            retVal = retVal || action.removeAll;
+            retVal = retVal || action.removeCart;
         });
 
         return retVal;
     }
 
+    hasLoadCartItem() {
+        let type = '';
+
+        this.q.forEach((action) => {
+            if (!type && action.loadCart) {
+                type = action.loadCart.type;
+            }
+        });
+
+        return type;
+    }
+
     setInStorage() {
         if (this.q.length > 0) {
             storage.setItem(this.PC_ACTIONS, this.q);
         } else {
             this.pcId = null;
             this.pcVersion = null;
+            this.pcType = null;
             storage.removeItem(this.PC_ACTIONS);
         }
     }
@@ -137,28 +149,32 @@ class PcActions {
 
     peek() {
         this.peeked = 0;
+        if (this.q[0]) {
+            this.peeked = 1;
+        }
         return this.q[0];
     }
 
     peekNext() {
         let action = null;
 
-        this.peeked += 1;
         if (this.peeked < this.q.length) {
             action = this.q[this.peeked];
+            this.peeked += 1;
         }
         return action;
     }
 
-    clear(num = this.q.length) {
+    clear(num = this.peeked) {
         this.q.splice(0, num);
         this.peeked -= num;
         this.setInStorage();
     }
 
-    setPcInfo(pcId, pcVersion) {
+    setPcInfo(pcId, pcVersion, pcType) {
         this.pcId = pcId;
         this.pcVersion = pcVersion;
+        this.pcType = pcType;
     }
 
     /**
@@ -170,7 +186,7 @@ class PcActions {
     push(cartAction) {
         let merged = false;
 
-        if (cartAction.removeAll) {
+        if (cartAction.removeCart || cartAction.loadCart) {
             this.clear();
         }
 
@@ -186,6 +202,7 @@ class PcActions {
         }
         this.pcId = cartAction.pcId;
         this.pcVersion = cartAction.pcVersion;
+        this.pcType = cartAction.pcType;
         this.setInStorage();
     }
 }
@@ -224,7 +241,7 @@ const getUrl = (path, pathParam, queryParams = {}) => {
     const queryStr = UrlService.toQueryString(queryParams);
     const queryString = queryStr.length > 0 ? `?${queryStr}` : '';
 
-    return `${ConfigService.getMarketConfig().awsUrl}/cart/v1/${path}/${pathParam}${queryString}`;
+    return `${ConfigService.getMarketConfig().awsUrl}/cart/v2/${path}/${pathParam}${queryString}`;
 };
 
 /**
@@ -233,14 +250,29 @@ const getUrl = (path, pathParam, queryParams = {}) => {
  * @param user
  * @return {Promise<void>}
  */
-const getPersistedCart = async (user) => {
+const getPersistedCart = async (user, type) => {
     const runConfig = RunConfigService.getRunConfig();
+    const lsCartType = CartService.getCartProperty('type');
+    const lsCartId = CartService.getCartProperty('id');
+
     const response = await axios({
-        method: 'POST',
-        url: getUrl('getCartByAccountId', user.id, {country: runConfig.country}),
+        method: 'GET',
+        type: type,
+        url: getUrl('getCartByAccountId', user.id, {country: runConfig.country, type: type}),
         headers: getHeaders(user.eid)
     });
-    return get(response, 'data.cart', null);
+    const pCart = response.data.cart;
+
+    if ((lsCartType != type) || (pCart && lsCartId && pCart.id != lsCartId) || (!pCart && lsCartId)) {
+        CartService.clearCart();
+    }
+
+    if (pCart) {
+        CartService.setCartProperties({id: pCart.id, version: response.data.version, type: type});
+    } else {
+        CartService.setCartProperties({type: type});
+    }
+    return pCart;
 };
 
 /**
@@ -260,9 +292,32 @@ const updatePersistedCart = async (user, cartId, payload) => {
     });
 
     const pCart = response.data.cart || null;
-    const cartOutdated = response.data.cartWasOutdated;
-    CartService.setCartProperties({version: pCart ? pCart.version : -1});
-    return {pCart, cartOutdated};
+    let cartOutdated = response.data.cartOutdated;
+    if (cartId && pCart.id !== cartId) {
+        CartService.clearCart();
+        cartOutdated = pCart.lineItems.length > 0;
+    }
+    CartService.setCartProperties({id: pCart.id, version: pCart ? response.data.version : -1});
+    return {pCart, cartOutdated: cartOutdated, version: response.data.version, type: response.data.type};
+};
+
+/**
+ * Removes a persisted cart
+ *
+ * @param {object} user
+ * @param {string} cartId
+ */
+const removePersistedCart = async (user, cartId) => {
+    try {
+        await axios({
+            method: 'DELETE',
+            url: getUrl('deleteCart', cartId,  {accountId: user.id}),
+            headers: getHeaders(user.eid)
+        });
+        CartService.setCartProperties({id: '', version: -1});
+    } catch (err) {
+        console.error('Unable to delete persistent cart', err);
+    }
 };
 
 /**
@@ -283,7 +338,7 @@ const addPersistedItemToLocal = (pItem, userId, country, language) => {
     return CartService.addSkuToCart({
         id: pItem.id,
         agelocme: pItem.agelocme,
-        sku: get(pItem, 'price.custom.fields.sku', ''),
+        sku: pItem.sku,
         userId: userId,
         cntryCd: country,
         language: language,
@@ -388,12 +443,10 @@ const mergeIntoLocalCart = async (userId, pCart) => {
     //Todo review (seems overly complicated)
     mergingIntoLocalCart = true;
     if (pCart) {
-        CartService.setCartProperties({id: pCart.id, version: pCart.version});
-
         const {country, language} = RunConfigService.getRunConfig();
         const lineItems = pCart.lineItems || [];
         const pItemsBySku = lineItems.reduce((skuArrs, pItem) => {
-            let skuArray = skuArrs.find((arr) => get(arr[0], 'price.custom.fields.sku') === get(pItem, 'price.custom.fields.sku'));
+            let skuArray = skuArrs.find((arr) => arr[0].sku === pItem.sku);
 
             if (!skuArray) {
                 skuArray = [pItem];
@@ -411,7 +464,7 @@ const mergeIntoLocalCart = async (userId, pCart) => {
             if (pSkuArray.length === 1) {
                 const pLineItem = pSkuArray[0];
                 // For agelocme the sku will be pLineItem.sku pLineItem.price.custom.fields.sku will be the content sku for agelocme
-                const matchedCartItems = cartItems.filter((cItem) => cItem.sku === pLineItem.sku || cItem.sku === get(pLineItem, 'price.custom.fields.sku'));
+                const matchedCartItems = cartItems.filter((cItem) => cItem.sku === pLineItem.sku || cItem.sku === pLineItem.sku);
 
                 if (matchedCartItems.length > 0) {
                     promises.push(mergeOneToOnePlus(pLineItem, matchedCartItems));
@@ -419,7 +472,7 @@ const mergeIntoLocalCart = async (userId, pCart) => {
                     promises.push(addPersistedItemToLocal(pLineItem, userId, country, language));
                 }
             } else {
-                const pSku = get(pSkuArray[0], 'price.custom.fields.sku');
+                const pSku = pSkuArray[0].sku;
                 const cartSkuItems = cartItems.filter((cItem) => cItem.sku === pSkuArray[0].sku || cItem.sku === pSku);
 
                 if (cartSkuItems.length === 0) {
@@ -435,7 +488,7 @@ const mergeIntoLocalCart = async (userId, pCart) => {
         // Remove local items that do not exist in persisted cart
         cartItems.forEach((cItem) => {
             if (cItem.id) {
-                if (!lineItems.some((pItem) => (pItem.sku === cItem.sku || get(pItem, 'price.custom.fields.sku') === cItem.sku) && !!pItem.oneTime === !cItem.isAdr)) {
+                if (!lineItems.some((pItem) => (pItem.sku === cItem.sku || pItem.sku === cItem.sku) && !!pItem.oneTime === !cItem.isAdr)) {
                     CartService.removeItemByKey(cItem.key);
                 }
             }
@@ -462,19 +515,9 @@ const getAction = (action, data) => {
                 gpid: data.globalProductID,
                 sku: data.sku,
                 quantity: data.quantity || data.qty,
-                channel: data.isAdr ? 'subscription' : 'order',
                 oneTime: !data.isAdr
             };
             break;
-        case REMOVE:
-            retVal.product = {
-                lineItemId: data.id,
-                quantity: data.quantity || data.qty
-            };
-            break;
-        case REMOVE_CART:
-            retVal.createNew = UserService.isLoggedIn();
-            break;
         default:
             console.error(`Bad update action: ${action}`);
             break;
@@ -497,6 +540,7 @@ const persistLocalItems = async (cartItems, user) => {
             const payload = {
                 accountId: user.id,
                 country: runConfig.country,
+                type: cartInfo.type,
                 version: cartInfo.version,
                 actions: []
             };
@@ -517,19 +561,28 @@ const persistLocalItems = async (cartItems, user) => {
  *
  * @return {Promise<void>}
  */
-const syncCart = async () => {
-    const user = UserService.getUser();
+const syncCart = async (type) => {
+    let user = UserService.getUser();
+    let pCart = null;
 
-    if (user) {
+    if (user && type) {
         try {
-            const pCart = await getPersistedCart(user);
-            const unPersistedItems = CartService.getItemData().filter(i => !i.id && !i.isBusinessPortfolio);
+            pCart = await getPersistedCart(user, type);
 
-            await mergeIntoLocalCart(user.id, pCart);
-            await persistLocalItems(unPersistedItems, user);
+            // there is a chance the user got logged out
+            user = UserService.getUser();
+            if (user) {
+                await mergeIntoLocalCart(user.id, pCart);
+            }
         } catch (err) {
             console.error('Failed to load the persisted cart!', err && err.response && err.response.data ? err.response.data : err);
         }
+        if (user) {
+            const unPersistedItems = CartService.getItemData().filter(i => !i.id && !i.isBusinessPortfolio);
+            await persistLocalItems(unPersistedItems, user);
+        } else {
+            CartService.clearCart();
+        }
     }
     events.setValue(events.shop.CART_SYNCED_ON_LOAD, [true]);
 };
@@ -543,7 +596,7 @@ const syncCartItems = (pCart) => {
     const syncItems = [];
     const cartItems = CartService.getItemData();
 
-    get(pCart, 'lineItems', []).forEach((pItem) => {
+    pCart.lineItems.forEach((pItem) => {
         const pGpid = pItem.gpid;
         const pSku = pItem.sku;
         const pIsAdr = !pItem.oneTime;
@@ -564,18 +617,19 @@ const syncCartItems = (pCart) => {
     CartService.syncPersistedInfo(syncItems);
 };
 
-const doPersistentUpdates = async (actions, pcId, pcVersion) => {
+const doPersistentUpdates = async (actions, pcId, pcVersion, pcType) => {
     try {
         const user = UserService.getUser();
         const payload = {
             accountId: user.id,
             country: RunConfigService.getRunConfig().country,
+            type: pcType,
             actions: actions,
             version: pcVersion
         };
 
-        const {pCart, cartOutdated} = await updatePersistedCart(user, pcId, payload);
-        pcActions.setPcInfo(pCart.id, pCart.version);
+        const {pCart, cartOutdated, version, type} = await updatePersistedCart(user, pcId, payload);
+        pcActions.setPcInfo(pCart.id, version, type);
         if (cartOutdated) {
             await mergeIntoLocalCart(user.id, pCart);
         }
@@ -585,6 +639,43 @@ const doPersistentUpdates = async (actions, pcId, pcVersion) => {
     }
 };
 
+const handleAddAction = (addAction, actions) => {
+    const item = addAction.item;
+    const agelocMe = /[a-zA-Z]/g;   // block agelocMe items until they can be persisted properly
+
+    if (!item.isSapLineItem && !agelocMe.test(item.sku)) {
+        actions.push(getAction(ADD, item));
+    }
+};
+
+const handleModifyAction = (modifyAction, actions) => {
+    const {type, item, qtyDiff} = modifyAction;
+
+    if (type === 'quantity-changed') {
+        if (qtyDiff != 0) {
+            actions.push(getAction(ADD, Object.assign({}, item, {quantity: qtyDiff})));
+        }
+    } else if (type === 'adr-status-changed' || type === 'product-changed') {
+        if (modifyAction.removeId) {
+            actions.push(getAction(ADD, Object.assign({}, item, {quantity: -9999, isAdr: !item.isAdr})));
+        }
+        actions.push(getAction(ADD, Object.assign({}, item, {quantity: qtyDiff || item.qty})));
+    }
+};
+
+const handleRemoveAction = (removeAction, actions) => {
+    const item = removeAction.item;
+
+    if (item.id) {
+        actions.push(getAction(ADD, Object.assign({}, item, {quantity: -item.qty})));
+    }
+};
+
+const handleRemoveItemsAction = (removeItemsAction, actions) => {
+    const removeItems = removeItemsAction.items || [];
+    removeItems.forEach((item) => actions.push(getAction(ADD, Object.assign({}, item, {quantity: - item.qty}))));
+};
+
 /**
  * Updates the persisted cart based on the CART_UPDATE events that are in
  * the action queue
@@ -593,64 +684,43 @@ const doPersistentUpdates = async (actions, pcId, pcVersion) => {
  */
 const persistCartUpdates = async () => {
     persistingCart = true;
-    let pcId = pcActions.pcId;
-    let pcVersion = pcActions.pcVersion;
+    let {pcId, pcVersion, pcType} = pcActions;
     let actions = [];
-    let peeked = 0;
+    let removeCart = false;
+    let loadCartType = null;
 
     if (pcActions.hasItems()) {
+        removeCart = pcActions.hasRemoveCartItem();
+        loadCartType = pcActions.hasLoadCartItem();
+
+        // even though there is no need to process the queue if there is a removeCart
+        // or a loadCart action they still need to get marked as processed so they will
+        // get removed.
         let info = pcActions.peek();
-        peeked += 1;
         while (info) {
             if (info.add && info.add.item.qty > 0) {
-                const item = info.add.item;
-
-                if (!item.isSapLineItem) {
-                    actions.push(getAction(ADD, item));
-                }
+                handleAddAction(info.add, actions);
             } else if (info.modify) {
-                const {type, item, qtyDiff} = info.modify;
-
-                if (type === 'quantity-changed') {
-                    if (qtyDiff > 0) {
-                        actions.push(getAction(ADD, Object.assign({}, item, {quantity: qtyDiff})));
-                    } else {
-                        if (item.id) {
-                            actions.push(getAction(REMOVE, {id: item.id, quantity: -qtyDiff}));
-                        }
-                    }
-                } else if (type === 'adr-status-changed' || type === 'product-changed') {
-                    if (info.modify.removeId) {
-                        actions.push(getAction(REMOVE, {id: info.modify.removeId, quantity: item.qty}));
-                    }
-                    actions.push(getAction(ADD, Object.assign({}, item, {quantity: qtyDiff || item.qty})));
-                }
+                handleModifyAction(info.modify, actions);
             } else if (info.remove) {
-                const item = info.remove.item;
-
-                if (item.id) {
-                    actions.push(getAction(REMOVE, item));
-                }
+                handleRemoveAction(info.remove, actions);
             } else if (info.removeItems) {
-                const removeItems = info.removeItemInfo || [];
-                removeItems.forEach((item) => actions.push(getAction(REMOVE, item)));
-            } else if (info.removeAll) {
-                if (actions.length > 0) {
-                    pcActions.clear(actions.length)
-                }
-                await doPersistentUpdates([getAction(REMOVE_CART)], pcId, pcVersion);
-                pcId = pcActions.pcId;
-                pcVersion = pcActions.pcVersion;
-                actions = [];
+                handleRemoveItemsAction(info.removeItems, actions);
             }
             info = pcActions.peekNext();
         }
     }
-    pcActions.clear(peeked);
 
-    if (actions.length > 0) {
-        await doPersistentUpdates(actions, pcId, pcVersion);
+    if (removeCart) {
+        await removePersistedCart(UserService.getUser(), pcId);
     }
+    if (loadCartType) {
+        await syncCart(loadCartType);
+    }
+    if (!(removeCart || loadCartType) && actions.length > 0) {
+        await doPersistentUpdates(actions, pcId, pcVersion, pcType);
+    }
+    pcActions.clear();
     if (pcActions.hasItems()) {
         clearTimeout(timerId);
         timerId = setTimeout(timerCallback, 200);
@@ -658,9 +728,48 @@ const persistCartUpdates = async () => {
     persistingCart = false;
 };
 
-const timerCallback = () => {
+const timerCallback = async () => {
     pcActions.syncAdrChange();
-    persistCartUpdates();
+    await persistCartUpdates();
+};
+
+const addAction = (info) => {
+    const user = UserService.getUser();
+
+    // If the code is currently merging the persistent cart into the local cart, cart update
+    // actions are being generated and those need to be ignored.  A loadCart action is not is
+    // generated elsewhere and should be let through.
+    if (user && (info.loadCart || !mergingIntoLocalCart)) {
+        if (info.add && info.add.item && !info.add.item.isBusinessPortfolio ||
+            info.modify || info.remove || info.removeItems || info.removeCart || info.loadCart) {
+            pcActions.push(info);
+            clearTimeout(timerId);
+            timerId = 0;
+            if (!persistingCart) {
+                if (info.removeCart) {
+                    // Likely a page refresh coming, wait for it to happen.
+                    // The cart actions will be picked up there.
+                    timerId = setTimeout(timerCallback, 1000);
+                } else if (info.loadCart) {
+                    timerId = setTimeout(timerCallback, 0);
+                } else {
+                    timerId = setTimeout(timerCallback, 200);
+                }
+            }
+        }
+    }
+};
+
+const loadPersistedCart = (type) => {
+    const lsType = CartService.getCartProperty('type');
+    if (type != lsType) {
+        if (!documentReady) {
+            CartService.clearCart();
+            CartService.setCartProperties({type: type});
+        } else {
+            addAction({loadCart: {type: type}});
+        }
+    }
 };
 
 /**
@@ -671,30 +780,13 @@ const initListeners = () => {
     // listener for CART_UPDATED events. As they come in they will get added
     // to a queue with a deloy of 200 ms before processing so if multiple actions
     // come in quickly they can be merged or just collected for processing.
-    events.subscribe(events.shop.CART_UPDATED, async (info) => {
-        const user = UserService.getUser();
-
-        if (!mergingIntoLocalCart && user) {
-            if (info.add && info.add.item && !info.add.item.isBusinessPortfolio || info.modify || info.remove || info.removeItems || info.removeAll) {
-                pcActions.push(info);
-                clearTimeout(timerId);
-                timerId = 0;
-                if (!persistingCart) {
-                    if (pcActions.hasRemoveAllItem()) {
-                        // Likely a page refresh coming, wait for it to happen.
-                        // The cart actions will be picked up there.
-                        timerId = setTimeout(timerCallback, 1000);
-                    } else {
-                        timerId = setTimeout(timerCallback, 200);
-                    }
-                }
-            }
-        }
-    });
+    events.subscribe(events.shop.CART_UPDATED, addAction);
 
     events.subscribe(events.authentication.LOGIN, function() {
         syncCart();
     });
+
+    events.subscribe('get-persisted-cart-type', loadPersistedCart)
 };
 
 /**
@@ -708,29 +800,35 @@ const initPersistentCartService = async () => {
         !window.location.pathname.startsWith("/content/login/corporate")) {
         initListeners();
         if (window.location.pathname != '/static/checkout/checkout.html') {
-            // Persiste changed that may not have gotten persisted before page refress
+            // Persist changed that may not have gotten persisted before page refress
             // like ADR changes that redirect before persisted cart gets updated.
             await persistCartUpdates();
 
             // now sync persisted cart into local.
-            await syncCart();
+            await syncCart(CartService.getCartProperty('type'));
         }
     } else {
         events.setValue(events.shop.CART_SYNCED_ON_LOAD, [true]);
     }
 };
 
-
 // This check is so persistent cart does not get initialized on a page
 // more than once.  This currently happens in profile.  The side affect here
 // is when an item gets added to the cart from the favorites page the separate
 // instances of persistent cart take turns persisting the item going from a
 // quantity of one to 900+ fairly quickly.
 // TODO: this check can be removed once profile is a static app.
+let documentReady = false;
 if (window.nsPersistentCartInitialized !== true) {
     window.nsPersistentCartInitialized = true;
     // Wait for page to load and them initialize the service
     $(document).ready(async function() {
+        documentReady = true;
         await initPersistentCartService();
     });
 }
+
+
+export default {
+    loadPersistedCart
+}

package/src/checkout/checkoutApi.js

@@ -34,11 +34,11 @@ function cleanupOrder() {
     }
     _cleanupPersonalOfferCheckout();
     if (order.adr && adr.shipImmediate) {
-        CartService.removeItems({all: true});
+        CartService.removeItems({all: true, removeCart: !nextOrder});
     } else if (order.adr) {
-        CartService.removeItems({cartAdrItems: true, sapAdrItems: true});
+        CartService.removeItems({cartAdrItems: true, sapAdrItems: true, removeCart: !nextOrder});
     } else {
-        CartService.removeItems({cartOrderItems: true, sapOrderItems: true});
+        CartService.removeItems({cartOrderItems: true, sapOrderItems: true, removeCart: !nextOrder});
     }
     // First order for this user has been placed now cleanup the cart
     CartService.setCartProperties({summerPromo: false, inSignup: false});