fix(store): renamed set method to overwrite

Renamed the new set method to overwrite in an effort to avoid conflicts with the entityStore method set.

Closes salesforce#663
PR salesforce#661

docs/docs/store.mdx

@@ -63,9 +63,9 @@ export class SessionService {
 }
 ```
 
-### `set()`
+### `overwrite()`
 
-When you don't just want to update the current store state but replace the state completely, you can call the `set()` method passing the new `state`:
+When you don't just want to update the current store state but replace the state completely, you can call the `overwrite()` method passing the new `state`:
 
 ```ts title="session.service.ts"
 import { SessionStore } from './session.store';
@@ -74,12 +74,12 @@ export class SessionService {
   constructor(private sessionStore: SessionStore) {}
 
   updateUserName(newName: string) {
-    this.sessionStore.set({ name: newName });
+    this.sessionStore.overwrite({ name: newName });
   }
 }
 ```
 
-As with `update()` the `set()` method also has a second option which gives you more control. It receives a `callback` function, which gets the current state, and returns a new **immutable** state, which will be the new value of the store. For example:
+As with `update()` the `overwrite()` method also has a second option which gives you more control. It receives a `callback` function, which gets the current state, and returns a new **immutable** state, which will be the new value of the store. For example:
 
 ```ts title="session.service.ts"
 import { SessionStore } from './session.store';
@@ -88,14 +88,14 @@ export class SessionService {
   constructor(private sessionStore: SessionStore) {}
 
   updateUserName(newName: string) {
-    this.sessionStore.set(state => ({
+    this.sessionStore.overwrite(state => ({
       name: newName
     }));
   }
 }
 ```
 
-You should use `set()` over `update()` when you want to completely replace the current state at the top level.
+You should use `overwrite()` over `update()` when you want to completely replace the current state at the top level.
 
 ```ts title="session.store.ts"
 type SessionState = SessionStateAuthenticated | SessionStateUnauthenticated;
@@ -138,7 +138,7 @@ Using the above state model and value of current state, if we call `this.store.u
 }
 ```
 
-Our value for tag has been updated but the user value from our previous state has stayed, this could lead to unintended side effects so in this case `this.store.set({ _tag: 'session-state-unauthenticated' })` may be a better option. When we use the `set()` method the following is the result:
+Our value for tag has been updated, but the user value from our previous state has stayed, this could lead to unintended side effects so in this case `this.store.overwrite({ _tag: 'session-state-unauthenticated' })` may be a better option. When we use the `overwrite()` method the following is the result:
 
 ```json "using the update() method"
 {

libs/akita/src/__tests__/set.spec.ts → libs/akita/src/__tests__/overwrite.spec.ts

@@ -29,19 +29,19 @@ class ExampleStore extends Store<ExampleState> {
 
 const exampleStore = new ExampleStore();
 
-describe('Store Set', () => {
+describe('Store Overwrite', () => {
   beforeEach(() => {
     exampleStore.reset();
   });
 
-  it('should set the store value replacing the previous state using a state object', () => {
-    exampleStore.set({ _tag: 'b', uniqueToB: 'This value is unique to b' });
+  it('should overwrite the store value replacing the previous state using a state object', () => {
+    exampleStore.overwrite({ _tag: 'b', uniqueToB: 'This value is unique to b' });
     expect(exampleStore._value()).toBeTruthy();
     expect(exampleStore._value()).toEqual({_tag: 'b', uniqueToB: 'This value is unique to b'});
   });
 
-  it('should set the store value replacing the previous state using a callback function', () => {
-    exampleStore.set((_) => ({ _tag: 'b', uniqueToB: 'This value is unique to b' }));
+  it('should overwrite the store value replacing the previous state using a callback function', () => {
+    exampleStore.overwrite((_) => ({ _tag: 'b', uniqueToB: 'This value is unique to b' }));
     expect(exampleStore._value()).toBeTruthy();
     expect(exampleStore._value()).toEqual({_tag: 'b', uniqueToB: 'This value is unique to b'});
   });

libs/akita/src/lib/store.ts

@@ -251,25 +251,25 @@ export class Store<S = any> {
 
   /**
    *
-   * Set the store's value, replacing the previous value.
+   * Overwrite the store's value, replacing the previous value.
    *
    * @example
    *
-   * this.store.update(state => {
+   * this.store.overwrite(state => {
    *   return {...}
    * })
    */
-  set(stateCallback: UpdateStateCallback<S>);
+  overwrite(stateCallback: UpdateStateCallback<S>);
   /**
    *
    * @example
    *
-   *  this.store.update({ token: token })
+   *  this.store.overwrite({ token: token })
    */
-  set(state: S);
-  set(stateOrCallback: S | UpdateStateCallback<S>): void {
-    isDev() && setAction('Set');
-    const withHookFn = (curr: S, newS: S) => this.akitaPreSet(curr,  newS as S);
+  overwrite(state: S);
+  overwrite(stateOrCallback: S | UpdateStateCallback<S>): void {
+    isDev() && setAction('Overwrite');
+    const withHookFn = (curr: S, newS: S) => this.akitaPreOverwrite(curr,  newS as S);
     this._setState(this.prepareNewState(stateOrCallback, this._value(), withHookFn));
   }
 
@@ -300,7 +300,7 @@ export class Store<S = any> {
   }
 
   // @internal
-  akitaPreSet(_: Readonly<S>, nextState: Readonly<S>): S {
+  akitaPreOverwrite(_: Readonly<S>, nextState: Readonly<S>): S {
     return nextState;
   }