fix: setItems type fixed in CartProviderState (#84)

* chore: package.lock is updated

* code: added setItems type to CartProviderState

* Added test for setItems

* test: removed .only from setItems tests to run all tests

* fix: updated setItems by the doc requirements

* test: updated setItems test for mock items to not have quantity

* test: added expectation to ensure quantity is implicitly added

* test: added test to ensure setItems does not ignore quantity input

* test: added test to ensure onSetItems is triggered

* test: Updated description for onSetItems trigger test

* test: ensure that setItems replaces the current items

* docs: setItems implicit quantity

* test: fixed false positive for replacing current items with new items

* refactor: setItems, mapping items

Author: Skidragon

README.md

@@ -166,14 +166,14 @@ ReactDOM.render(
 | `onItemRemove` | _No_     | Triggered on items removed from your cart.                                                                                                                 |
 | `storage`      | _No_     | Must return `[getter, setter]`.                                                                                                                            |
 | `metadata`     | _No_     | Custom global state on the cart. Stored inside of `metadata`.                                                                                              |
-
 ## `useCart`
 
 The `useCart` hook exposes all the getter/setters for your cart state.
 
 ### `setItems(items)`
 
-The `setItems` method should be used to set all items in the cart. This will overwrite any existing cart items.
+The `setItems` method should be used to set all items in the cart. This will overwrite any existing cart items. A `quantity` default of 1 will be set for an item implicitly if no `quantity` is specified.
+
 
 #### Args
 

package-lock.json

@@ -28,6 +28,7 @@ interface CartProviderState extends InitialState {
   addItem: (item: Item, quantity?: number) => void;
   removeItem: (id: Item["id"]) => void;
   updateItem: (id: Item["id"], payload: object) => void;
+  setItems: (items: Item[]) => void;
   updateItemQuantity: (id: Item["id"], quantity: number) => void;
   emptyCart: () => void;
   getItem: (id: Item["id"]) => any | undefined;
@@ -191,7 +192,10 @@ export const CartProvider: React.FC<{
   const setItems = (items: Item[]) => {
     dispatch({
       type: "SET_ITEMS",
-      payload: items,
+      payload: items.map(item => ({
+        ...item,
+        quantity: item.quantity || 1
+      })),
     });
 
     onSetItems && onSetItems(items);

src/index.tsx

@@ -450,3 +450,76 @@ describe("updateCartMetadata", () => {
     });
   });
 });
+describe("setItems", () => {
+  test("set cart items state", () => {
+    const items = [{ id: "test", price: 1000 }, { id: "test2", price: 2000 }];
+    
+    const wrapper: FC<Props> = ({ children }) => (
+      <CartProvider defaultItems={[]}>{children}</CartProvider>
+    );
+    const { result } = renderHook(() => useCart(), {
+      wrapper,
+    });
+
+    act(() =>
+      result.current.setItems(items)
+    );
+    expect(result.current.items).toHaveLength(2);
+    expect(result.current.totalItems).toBe(2);
+    expect(result.current.totalUniqueItems).toBe(2);
+    expect(result.current.isEmpty).toBe(false);
+    expect(result.current.items).toContainEqual(
+      expect.objectContaining({ id: "test2", price: 2000, quantity: 1 })
+    );
+  })
+  test("add custom quantities with setItems", () => {
+    const items = [{ id: "test", price: 1000, quantity: 2 }, { id: "test2", price: 2000, quantity: 1 }];
+    const wrapper: FC<Props> = ({ children }) => (
+      <CartProvider defaultItems={[]}>{children}</CartProvider>
+    );
+    const { result } = renderHook(() => useCart(), {
+      wrapper,
+    });
+
+    act(() =>
+      result.current.setItems(items)
+    );
+    expect(result.current.items).toHaveLength(2);
+    expect(result.current.totalItems).toBe(3);
+    expect(result.current.totalUniqueItems).toBe(2);
+  })
+  test("current items is replaced when setItems has been called with a new set of items", () => {
+    const itemToBeReplaced = { id: "test", price: 1000 };
+    const wrapper: FC<Props> = ({ children }) => (
+      <CartProvider defaultItems={[itemToBeReplaced]}>{children}</CartProvider>
+    );
+    const { result } = renderHook(() => useCart(), {
+      wrapper,
+    });
+    const items = [{ id: "test2", price: 2000}, { id: "test3", price: 3000}];
+    act(() =>
+      result.current.setItems(items)
+    );
+    expect(result.current.items).toHaveLength(2);
+    expect(result.current.items).not.toContainEqual(
+    expect.objectContaining(itemToBeReplaced)
+    );
+  })
+  test("trigger onSetItems when setItems is called", () => {
+     let called = false;
+
+    const wrapper: FC<Props> = ({ children }) => (
+      <CartProvider onSetItems={() => (called = true)}>{children}</CartProvider>
+    );
+
+    const { result } = renderHook(() => useCart(), {
+      wrapper,
+    });
+
+    const items = [{ id: "test", price: 1000 }];
+
+    act(() => result.current.setItems(items));
+
+    expect(called).toBe(true);
+  })
+})