Merge pull request #6669 from abpframework/feat/6667

Renamed the patch method of InternalStore to deepPatch and add a new method called patch

npm/ng-packs/packages/core/src/lib/tests/internal-store.spec.ts

@@ -17,25 +17,49 @@ const mockInitialState = {
 
 type MockState = typeof mockInitialState;
 
-const patch1: DeepPartial<MockState> = { foo: { bar: { baz: [() => {}] } } };
-const expected1: MockState = clone(mockInitialState);
-expected1.foo.bar.baz = patch1.foo.bar.baz;
+const deepPatch1: DeepPartial<MockState> = { foo: { bar: { baz: [() => {}] } } };
+const deepPatchExpected1: MockState = clone(mockInitialState);
+deepPatchExpected1.foo.bar.baz = deepPatch1.foo.bar.baz;
 
-const patch2: DeepPartial<MockState> = { foo: { bar: { qux: Promise.resolve() } } };
-const expected2: MockState = clone(mockInitialState);
-expected2.foo.bar.qux = patch2.foo.bar.qux;
+const deepPatch2: DeepPartial<MockState> = { foo: { bar: { qux: Promise.resolve() } } };
+const deepPatchExpected2: MockState = clone(mockInitialState);
+deepPatchExpected2.foo.bar.qux = deepPatch2.foo.bar.qux;
 
-const patch3: DeepPartial<MockState> = { foo: { n: 1 } };
-const expected3: MockState = clone(mockInitialState);
-expected3.foo.n = patch3.foo.n;
+const deepPatch3: DeepPartial<MockState> = { foo: { n: 1 } };
+const deepPatchExpected3: MockState = clone(mockInitialState);
+deepPatchExpected3.foo.n = deepPatch3.foo.n;
 
-const patch4: DeepPartial<MockState> = { x: 'X' };
-const expected4: MockState = clone(mockInitialState);
-expected4.x = patch4.x;
+const deepPatch4: DeepPartial<MockState> = { x: 'X' };
+const deepPatchExpected4: MockState = clone(mockInitialState);
+deepPatchExpected4.x = deepPatch4.x;
 
-const patch5: DeepPartial<MockState> = { a: true };
-const expected5: MockState = clone(mockInitialState);
-expected5.a = patch5.a;
+const deepPatch5: DeepPartial<MockState> = { a: true };
+const deepPatchExpected5: MockState = clone(mockInitialState);
+deepPatchExpected5.a = deepPatch5.a;
+
+const patch1: Partial<MockState> = {
+  foo: { bar: { baz: [() => {}] } } as typeof mockInitialState.foo,
+};
+const patchExpected1: MockState = clone(mockInitialState);
+patchExpected1.foo = patch1.foo;
+
+const patch2: Partial<MockState> = {
+  foo: { bar: { qux: Promise.resolve() } } as typeof mockInitialState.foo,
+};
+const patchExpected2: MockState = clone(mockInitialState);
+patchExpected2.foo = patch2.foo;
+
+const patch3: Partial<MockState> = { foo: { n: 1 } as typeof mockInitialState.foo };
+const patchExpected3: MockState = clone(mockInitialState);
+patchExpected3.foo = patch3.foo;
+
+const patch4: Partial<MockState> = { x: 'X' };
+const patchExpected4: MockState = clone(mockInitialState);
+patchExpected4.x = patch4.x;
+
+const patch5: Partial<MockState> = { a: true };
+const patchExpected5: MockState = clone(mockInitialState);
+patchExpected5.a = patch5.a;
 
 describe('Internal Store', () => {
   describe('sliceState', () => {
@@ -52,24 +76,38 @@ describe('Internal Store', () => {
       async ({ selector, expected }) => {
         const store = new InternalStore(mockInitialState);
 
-        const value = await store
-          .sliceState(selector)
-          .pipe(take(1))
-          .toPromise();
+        const value = await store.sliceState(selector).pipe(take(1)).toPromise();
 
         expect(value).toEqual(expected);
       },
     );
   });
 
+  describe('deepPatchState', () => {
+    test.each`
+      patch         | expected
+      ${deepPatch1} | ${deepPatchExpected1}
+      ${deepPatch2} | ${deepPatchExpected2}
+      ${deepPatch3} | ${deepPatchExpected3}
+      ${deepPatch4} | ${deepPatchExpected4}
+      ${deepPatch5} | ${deepPatchExpected5}
+    `('should set state as $expected when patch is $patch', ({ patch, expected }) => {
+      const store = new InternalStore(mockInitialState);
+
+      store.deepPatch(patch);
+
+      expect(store.state).toEqual(expected);
+    });
+  });
+
   describe('patchState', () => {
     test.each`
       patch     | expected
-      ${patch1} | ${expected1}
-      ${patch2} | ${expected2}
-      ${patch3} | ${expected3}
-      ${patch4} | ${expected4}
-      ${patch5} | ${expected5}
+      ${patch1} | ${patchExpected1}
+      ${patch2} | ${patchExpected2}
+      ${patch3} | ${patchExpected3}
+      ${patch4} | ${patchExpected4}
+      ${patch5} | ${patchExpected5}
     `('should set state as $expected when patch is $patch', ({ patch, expected }) => {
       const store = new InternalStore(mockInitialState);
 
@@ -86,12 +124,12 @@ describe('Internal Store', () => {
       const onQux$ = store.sliceUpdate(state => state.foo.bar.qux);
 
       onQux$.pipe(take(1)).subscribe(value => {
-        expect(value).toEqual(patch2.foo.bar.qux);
+        expect(value).toEqual(deepPatch2.foo.bar.qux);
         done();
       });
 
-      store.patch(patch1);
-      store.patch(patch2);
+      store.deepPatch(deepPatch1);
+      store.deepPatch(deepPatch2);
     });
   });
 
@@ -99,7 +137,7 @@ describe('Internal Store', () => {
     it('should reset state to initialState', () => {
       const store = new InternalStore(mockInitialState);
 
-      store.patch(patch1);
+      store.deepPatch(deepPatch1);
       store.reset();
 
       expect(store.state).toEqual(mockInitialState);

npm/ng-packs/packages/core/src/lib/utils/internal-store-utils.ts

@@ -25,7 +25,18 @@ export class InternalStore<State> {
 
   constructor(private initialState: State) {}
 
-  patch(state: DeepPartial<State>) {
+  patch(state: Partial<State>) {
+    let patchedState = state as State;
+
+    if (typeof state === 'object' && !Array.isArray(state)) {
+      patchedState = { ...this.state, ...state };
+    }
+
+    this.state$.next(patchedState);
+    this.update$.next(patchedState);
+  }
+
+  deepPatch(state: DeepPartial<State>) {
     this.state$.next(deepMerge(this.state, state));
     this.update$.next(state);
   }