From b48a51dd2f79ecd37f4d0c21c0a1162b1552db20 Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Fri, 13 Sep 2024 09:15:26 -0700
Subject: [PATCH 1/7] docs: replace js files with ts files

---
 docs/tutorials/quick-start.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/tutorials/quick-start.md b/docs/tutorials/quick-start.md
index 34b1429..139258c 100644
--- a/docs/tutorials/quick-start.md
+++ b/docs/tutorials/quick-start.md
@@ -45,9 +45,9 @@ npm install @reduxjs/toolkit angular-redux
 
 ### Create a Redux Store
 
-Create a file named `src/app/store.js`. Import the `configureStore` API from Redux Toolkit. We'll start by creating an empty Redux store, and exporting it:
+Create a file named `src/app/store.ts`. Import the `configureStore` API from Redux Toolkit. We'll start by creating an empty Redux store, and exporting it:
 
-```typescript title="app/store.js"
+```typescript title="app/store.ts"
 import { configureStore } from '@reduxjs/toolkit'
 
 export default configureStore({
@@ -80,13 +80,13 @@ bootstrapApplication(AppComponent, {
 
 ### Create a Redux State Slice
 
-Add a new file named `src/features/counter/counterSlice.js`. In that file, import the `createSlice` API from Redux Toolkit.
+Add a new file named `src/features/counter/counterSlice.ts`. In that file, import the `createSlice` API from Redux Toolkit.
 
 Creating a slice requires a string name to identify the slice, an initial state value, and one or more reducer functions to define how the state can be updated. Once a slice is created, we can export the generated Redux action creators and the reducer function for the whole slice.
 
 Redux requires that [we write all state updates immutably, by making copies of data and updating the copies](https://redux.js.org/tutorials/fundamentals/part-2-concepts-data-flow#immutability). However, Redux Toolkit's `createSlice` and `createReducer` APIs use [Immer](https://immerjs.github.io/immer/) inside to allow us to [write "mutating" update logic that becomes correct immutable updates](https://redux.js.org/tutorials/fundamentals/part-8-modern-redux#immutable-updates-with-immer).
 
-```js title="features/counter/counterSlice.js"
+```js title="features/counter/counterSlice.ts"
 import { createSlice } from '@reduxjs/toolkit'
 
 export const counterSlice = createSlice({
@@ -122,7 +122,7 @@ export default counterSlice.reducer
 
 Next, we need to import the reducer function from the counter slice and add it to our store. By defining a field inside the `reducer` parameter, we tell the store to use this slice reducer function to handle all updates to that state.
 
-```js title="app/store.js"
+```js title="app/store.ts"
 import { configureStore } from '@reduxjs/toolkit'
 // highlight-next-line
 import counterReducer from '../features/counter/counterSlice'

From 66cd4c72fc8916f53b649e5e15a2c6a9363283aa Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Fri, 13 Sep 2024 10:38:33 -0700
Subject: [PATCH 2/7] chore: fix website build

---
 website/docusaurus.config.js | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/website/docusaurus.config.js b/website/docusaurus.config.js
index af8d56f..123302e 100644
--- a/website/docusaurus.config.js
+++ b/website/docusaurus.config.js
@@ -112,10 +112,6 @@ const siteConfig = {
               label: 'Introduction',
               to: 'introduction/getting-started',
             },
-            {
-              label: 'Guides',
-              to: 'troubleshooting',
-            },
           ],
         },
         {

From 117cbb10344039c506b2e507ccfbe45e66863a71 Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Sat, 14 Sep 2024 03:16:41 -0700
Subject: [PATCH 3/7] test: add tests for Subscription and shallowEqual

---
 .../src/lib/utils/Subscription.ts             |  4 -
 projects/angular-redux/src/lib/utils/batch.ts |  4 -
 projects/angular-redux/src/public-api.ts      |  1 +
 .../src/tests/utils/Subscription.spec.ts      | 58 +++++++++++++
 .../src/tests/utils/shallowEqual.spec.ts      | 83 +++++++++++++++++++
 5 files changed, 142 insertions(+), 8 deletions(-)
 delete mode 100644 projects/angular-redux/src/lib/utils/batch.ts
 create mode 100644 projects/angular-redux/src/tests/utils/Subscription.spec.ts
 create mode 100644 projects/angular-redux/src/tests/utils/shallowEqual.spec.ts

diff --git a/projects/angular-redux/src/lib/utils/Subscription.ts b/projects/angular-redux/src/lib/utils/Subscription.ts
index c9f8412..476c999 100644
--- a/projects/angular-redux/src/lib/utils/Subscription.ts
+++ b/projects/angular-redux/src/lib/utils/Subscription.ts
@@ -1,5 +1,3 @@
-import { defaultNoopBatch as batch } from './batch'
-
 // encapsulates the subscription logic for connecting a component to the redux store, as
 // well as nesting subscriptions of descendant components, so that we can ensure the
 // ancestor components re-render before descendants
@@ -23,13 +21,11 @@ function createListenerCollection() {
     },
 
     notify() {
-      batch(() => {
         let listener = first
         while (listener) {
           listener.callback()
           listener = listener.next
         }
-      })
     },
 
     get() {
diff --git a/projects/angular-redux/src/lib/utils/batch.ts b/projects/angular-redux/src/lib/utils/batch.ts
deleted file mode 100644
index b3bcb58..0000000
--- a/projects/angular-redux/src/lib/utils/batch.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-// Default to a dummy "batch" implementation that just runs the callback
-export function defaultNoopBatch(callback: () => void) {
-  callback()
-}
diff --git a/projects/angular-redux/src/public-api.ts b/projects/angular-redux/src/public-api.ts
index da62d3c..ea18bbc 100644
--- a/projects/angular-redux/src/public-api.ts
+++ b/projects/angular-redux/src/public-api.ts
@@ -8,3 +8,4 @@ export * from './lib/inject-store';
 export * from './lib/provide-redux';
 export * from "./lib/provider"
 export * from "./lib/utils/shallowEqual"
+export type { Subscription } from './lib/utils/Subscription'
diff --git a/projects/angular-redux/src/tests/utils/Subscription.spec.ts b/projects/angular-redux/src/tests/utils/Subscription.spec.ts
new file mode 100644
index 0000000..07a51f8
--- /dev/null
+++ b/projects/angular-redux/src/tests/utils/Subscription.spec.ts
@@ -0,0 +1,58 @@
+import {  createSubscription, Subscription } from '../../lib/utils/Subscription'
+import { Store } from 'redux'
+
+describe('Subscription', () => {
+  let notifications: string[]
+  let store: Store
+  let parent: Subscription
+
+  beforeEach(() => {
+    notifications = []
+    store = { subscribe: () => jest.fn() } as unknown as Store
+
+    parent = createSubscription(store)
+    parent.onStateChange = () => {}
+    parent.trySubscribe()
+  })
+
+  function subscribeChild(name: string) {
+    const child = createSubscription(store, parent)
+    child.onStateChange = () => notifications.push(name)
+    child.trySubscribe()
+    return child
+  }
+
+  it('listeners are notified in order', () => {
+    subscribeChild('child1')
+    subscribeChild('child2')
+    subscribeChild('child3')
+    subscribeChild('child4')
+
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual(['child1', 'child2', 'child3', 'child4'])
+  })
+
+  it('listeners can be unsubscribed', () => {
+    const child1 = subscribeChild('child1')
+    const child2 = subscribeChild('child2')
+    const child3 = subscribeChild('child3')
+
+    child2.tryUnsubscribe()
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual(['child1', 'child3'])
+    notifications.length = 0
+
+    child1.tryUnsubscribe()
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual(['child3'])
+    notifications.length = 0
+
+    child3.tryUnsubscribe()
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual([])
+  })
+})
diff --git a/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts b/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts
new file mode 100644
index 0000000..3dbdb79
--- /dev/null
+++ b/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts
@@ -0,0 +1,83 @@
+import { shallowEqual } from '../../public-api'
+
+describe('Utils', () => {
+  describe('shallowEqual', () => {
+    it('should return true if arguments fields are equal', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: undefined },
+          { a: 1, b: 2, c: undefined },
+        ),
+      ).toBe(true)
+
+      expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).toBe(
+        true,
+      )
+
+      const o = {}
+      expect(shallowEqual({ a: 1, b: 2, c: o }, { a: 1, b: 2, c: o })).toBe(
+        true,
+      )
+
+      const d = function () {
+        return 1
+      }
+      expect(
+        shallowEqual({ a: 1, b: 2, c: o, d }, { a: 1, b: 2, c: o, d }),
+      ).toBe(true)
+    })
+
+    it('should return false if arguments fields are different function identities', () => {
+      expect(
+        shallowEqual(
+          {
+            a: 1,
+            b: 2,
+            d: function () {
+              return 1
+            },
+          },
+          {
+            a: 1,
+            b: 2,
+            d: function () {
+              return 1
+            },
+          },
+        ),
+      ).toBe(false)
+    })
+
+    it('should return false if first argument has too many keys', () => {
+      expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false)
+    })
+
+    it('should return false if second argument has too many keys', () => {
+      expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBe(false)
+    })
+
+    it('should return false if arguments have different keys', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: undefined },
+          { a: 1, bb: 2, c: undefined },
+        ),
+      ).toBe(false)
+    })
+
+    it('should compare two NaN values', () => {
+      expect(shallowEqual(NaN, NaN)).toBe(true)
+    })
+
+    it('should compare empty objects, with false', () => {
+      expect(shallowEqual({}, false)).toBe(false)
+      expect(shallowEqual(false, {})).toBe(false)
+      expect(shallowEqual([], false)).toBe(false)
+      expect(shallowEqual(false, [])).toBe(false)
+    })
+
+    it('should compare two zero values', () => {
+      expect(shallowEqual(0, 0)).toBe(true)
+    })
+  })
+})

From 91c658512b659b357b4e365a987304be6a7ba16d Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Sat, 14 Sep 2024 03:18:51 -0700
Subject: [PATCH 4/7] chore: add prettier and format files

---
 .github/workflows/test.yml                    |   4 +-
 angular.json                                  |  17 +-
 docs/introduction/getting-started.md          |  47 ++-
 docs/tutorials/quick-start.md                 |  65 ++--
 docs/tutorials/typescript.md                  |  56 ++--
 package.json                                  |   5 +-
 .../src/app/app.component.ts                  |  28 +-
 .../angular-redux-demo/src/app/app.config.ts  |   8 +-
 .../src/app/store/counter-slice.ts            |  20 +-
 .../angular-redux-demo/src/app/store/index.ts |  10 +-
 projects/angular-redux-demo/src/index.html    |  20 +-
 projects/angular-redux-demo/src/main.ts       |   5 +-
 projects/angular-redux-demo/tsconfig.app.json |   8 +-
 projects/angular-redux/README.md              |  32 +-
 projects/angular-redux/ng-package.json        |   2 +-
 .../angular-redux/schematics-core/index.ts    |  11 +-
 .../testing/create-app-module.ts              |   8 +-
 .../schematics-core/testing/create-package.ts |   4 +-
 .../testing/create-reducers.ts                |   4 +-
 .../testing/create-workspace.ts               |  12 +-
 .../schematics-core/utility/ast-utils.ts      |  98 +++---
 .../schematics-core/utility/change.ts         |  24 +-
 .../schematics-core/utility/find-component.ts |  12 +-
 .../schematics-core/utility/find-module.ts    |   8 +-
 .../schematics-core/utility/json-utilts.ts    |   2 +-
 .../schematics-core/utility/package.ts        |   2 +-
 .../schematics-core/utility/project.ts        |   8 +-
 .../schematics-core/utility/standalone.ts     |  58 ++--
 .../schematics-core/utility/strings.ts        |   8 +-
 .../schematics-core/utility/visitors.ts       |  40 +--
 .../angular-redux/schematics/jest.config.mjs  |  12 +-
 .../schematics/ng-add/index.spec.ts           |  18 +-
 .../angular-redux/schematics/ng-add/index.ts  |  41 +--
 .../schematics/tsconfig.spec.json             |  10 +-
 .../angular-redux/src/lib/inject-dispatch.ts  |  27 +-
 .../angular-redux/src/lib/inject-selector.ts  |  67 ++--
 .../angular-redux/src/lib/inject-store.ts     |  40 +--
 .../angular-redux/src/lib/provide-redux.ts    |  17 +-
 projects/angular-redux/src/lib/provider.ts    |  39 ++-
 projects/angular-redux/src/lib/types.ts       |   2 +-
 .../src/lib/utils/Subscription.ts             | 138 ++++----
 .../src/lib/utils/shallowEqual.ts             |  18 +-
 projects/angular-redux/src/public-api.ts      |   6 +-
 .../src/tests/inject-dispatch.spec.ts         |  28 +-
 .../inject-selector-and-dispatch.spec.ts      |  59 ++--
 .../src/tests/inject-selector.spec.ts         | 295 +++++++++---------
 .../src/tests/injections.withTypes.spec.ts    |  62 ++--
 .../src/tests/utils/Subscription.spec.ts      |  76 ++---
 .../src/tests/utils/shallowEqual.spec.ts      |  60 ++--
 projects/angular-redux/tsconfig.lib.json      |   4 +-
 .../angular-redux/tsconfig.schematics.json    |   6 +-
 projects/angular-redux/tsconfig.spec.json     |  14 +-
 tsconfig.json                                 |   9 +-
 website/docusaurus.config.js                  | 121 ++++---
 website/sidebars.js                           |  21 +-
 website/src/pages/index.js                    |  82 ++---
 website/src/pages/styles.module.css           |   2 +-
 website/src/theme/NotFound.js                 |  32 +-
 website/static/css/custom.css                 |  10 +-
 website/static/scripts/codeblock.js           |  50 +--
 website/static/scripts/monokaiTheme.js        |  42 +--
 website/static/scripts/sidebarScroll.js       |  14 +-
 yarn.lock                                     |  10 +
 63 files changed, 1012 insertions(+), 1046 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 2de0c38..15ad816 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -10,8 +10,8 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: '20.x'
-          cache: 'yarn'
+          node-version: "20.x"
+          cache: "yarn"
 
       - name: Install packages
         run: yarn install
diff --git a/angular.json b/angular.json
index 80f0bfb..561d26b 100644
--- a/angular.json
+++ b/angular.json
@@ -27,14 +27,9 @@
         "test": {
           "builder": "@angular-devkit/build-angular:jest",
           "options": {
-            "exclude": [
-              "**/schematics/ng-add/*.spec.ts"
-            ],
+            "exclude": ["**/schematics/ng-add/*.spec.ts"],
             "tsConfig": "projects/angular-redux/tsconfig.spec.json",
-            "polyfills": [
-              "zone.js",
-              "zone.js/testing"
-            ]
+            "polyfills": ["zone.js", "zone.js/testing"]
           }
         }
       }
@@ -79,9 +74,7 @@
             "outputPath": "dist/angular-redux-demo",
             "index": "projects/angular-redux-demo/src/index.html",
             "browser": "projects/angular-redux-demo/src/main.ts",
-            "polyfills": [
-              "zone.js"
-            ],
+            "polyfills": ["zone.js"],
             "tsConfig": "projects/angular-redux-demo/tsconfig.app.json",
             "assets": [
               {
@@ -89,9 +82,7 @@
                 "input": "projects/angular-redux-demo/public"
               }
             ],
-            "styles": [
-              "projects/angular-redux-demo/src/styles.css"
-            ],
+            "styles": ["projects/angular-redux-demo/src/styles.css"],
             "scripts": []
           },
           "configurations": {
diff --git a/docs/introduction/getting-started.md b/docs/introduction/getting-started.md
index b6cb8dd..a755b53 100644
--- a/docs/introduction/getting-started.md
+++ b/docs/introduction/getting-started.md
@@ -3,7 +3,7 @@ id: getting-started
 title: Getting Started with Angular Redux
 hide_title: true
 sidebar_label: Getting Started
-description: 'Introduction > Getting Started: First steps with Angular Redux'
+description: "Introduction > Getting Started: First steps with Angular Redux"
 ---
 
 # Getting Started with Angular Redux
@@ -25,9 +25,9 @@ ng add @reduxjs/angular-redux@latest
 #### Optional `ng add` flags
 
 | flag          | description                                                                                                                                                                         | value type | default value |
-|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------|
-| `--path`      | Path to the module that you wish to add the import for the `provideRedux` to.                                                                                           | `string`   ||
-| `--project`   | Name of the project defined in your `angular.json` to help locating the module to add the `provideRedux` to.                                                                        | `string`   ||
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | ------------- |
+| `--path`      | Path to the module that you wish to add the import for the `provideRedux` to.                                                                                                       | `string`   |               |
+| `--project`   | Name of the project defined in your `angular.json` to help locating the module to add the `provideRedux` to.                                                                        | `string`   |               |
 | `--module`    | Name of file containing the module that you wish to add the import for the `provideRedux` to. Can also include the relative path to the file. For example, `src/app/app.module.ts`. | `string`   | `app`         |
 | `--storePath` | The file path to create the state in.                                                                                                                                               | `string`   | `store`       |
 
@@ -50,7 +50,6 @@ npm install @reduxjs/angular-redux
 yarn add @reduxjs/angular-redux
 ```
 
-
 You'll also need to [install Redux](https://redux.js.org/introduction/installation) and [set up a Redux store](https://redux.js.org/recipes/configuring-your-store/) in your app.
 
 Angular-Redux is written in TypeScript, so all types are automatically included.
@@ -62,15 +61,13 @@ Angular-Redux is written in TypeScript, so all types are automatically included.
 Angular Redux includes a `provideRedux` provider factory, which makes the Redux store available to the rest of your app:
 
 ```typescript
-import { bootstrapApplication } from '@angular/platform-browser';
+import { bootstrapApplication } from "@angular/platform-browser";
 import { provideRedux } from "angular-redux";
-import { AppComponent } from './app/app.component';
-import { store } from './store'
+import { AppComponent } from "./app/app.component";
+import { store } from "./store";
 
 bootstrapApplication(AppComponent, {
-  providers: [
-    provideRedux({ store })
-  ]
+  providers: [provideRedux({ store })],
 });
 ```
 
@@ -81,29 +78,25 @@ Angular Redux provides a pair of custom Angular injectable functions that allow
 `injectSelector` reads a value from the store state and subscribes to updates, while `injectDispatch` returns the store's `dispatch` method to let you dispatch actions.
 
 ```typescript
-import { Component } from '@angular/core'
+import { Component } from "@angular/core";
 import { injectSelector, injectDispatch } from "@reduxjs/angular-redux";
-import { decrement, increment } from './store/counter-slice'
-import { RootState } from './store'
+import { decrement, increment } from "./store/counter-slice";
+import { RootState } from "./store";
 
 @Component({
-  selector: 'app-root',
+  selector: "app-root",
   standalone: true,
   template: `
-      <button (click)="dispatch(increment())">
-        Increment
-      </button>
-      <span>{{ count() }}</span>
-      <button (click)="dispatch(decrement())">
-        Decrement
-      </button>
-  `
+    <button (click)="dispatch(increment())">Increment</button>
+    <span>{{ count() }}</span>
+    <button (click)="dispatch(decrement())">Decrement</button>
+  `,
 })
 export class AppComponent {
-  count = injectSelector((state: RootState) => state.counter.value)
-  dispatch = injectDispatch()
-  increment = increment
-  decrement = decrement
+  count = injectSelector((state: RootState) => state.counter.value);
+  dispatch = injectDispatch();
+  increment = increment;
+  decrement = decrement;
 }
 ```
 
diff --git a/docs/tutorials/quick-start.md b/docs/tutorials/quick-start.md
index 139258c..7d3a529 100644
--- a/docs/tutorials/quick-start.md
+++ b/docs/tutorials/quick-start.md
@@ -48,11 +48,11 @@ npm install @reduxjs/toolkit angular-redux
 Create a file named `src/app/store.ts`. Import the `configureStore` API from Redux Toolkit. We'll start by creating an empty Redux store, and exporting it:
 
 ```typescript title="app/store.ts"
-import { configureStore } from '@reduxjs/toolkit'
+import { configureStore } from "@reduxjs/toolkit";
 
 export default configureStore({
   reducer: {},
-})
+});
 ```
 
 This creates a Redux store, and also automatically configure the Redux DevTools extension so that you can inspect the store while developing.
@@ -62,19 +62,18 @@ This creates a Redux store, and also automatically configure the Redux DevTools
 Once the store is created, we can make it available to our Angular components by putting an Angular Redux `provideRedux` in our application's `providers` array in `src/main.ts`. Import the Redux store we just created, put a `provideRedux` in your application's `providers` array, and pass the store as a prop:
 
 ```typescript title="main.ts"
-
-import { bootstrapApplication } from '@angular/platform-browser';
-import { AppComponent } from './app/app.component';
+import { bootstrapApplication } from "@angular/platform-browser";
+import { AppComponent } from "./app/app.component";
 // highlight-start
 import { provideRedux } from "angular-redux";
-import { store } from './store'
+import { store } from "./store";
 // highlight-end
 
 bootstrapApplication(AppComponent, {
   providers: [
     // highlight-next-line
-    provideRedux({ store })
-  ]
+    provideRedux({ store }),
+  ],
 });
 ```
 
@@ -87,10 +86,10 @@ Creating a slice requires a string name to identify the slice, an initial state
 Redux requires that [we write all state updates immutably, by making copies of data and updating the copies](https://redux.js.org/tutorials/fundamentals/part-2-concepts-data-flow#immutability). However, Redux Toolkit's `createSlice` and `createReducer` APIs use [Immer](https://immerjs.github.io/immer/) inside to allow us to [write "mutating" update logic that becomes correct immutable updates](https://redux.js.org/tutorials/fundamentals/part-8-modern-redux#immutable-updates-with-immer).
 
 ```js title="features/counter/counterSlice.ts"
-import { createSlice } from '@reduxjs/toolkit'
+import { createSlice } from "@reduxjs/toolkit";
 
 export const counterSlice = createSlice({
-  name: 'counter',
+  name: "counter",
   initialState: {
     value: 0,
   },
@@ -101,21 +100,21 @@ export const counterSlice = createSlice({
       // which detects changes to a "draft state" and produces a brand new
       // immutable state based off those changes.
       // Also, no return statement is required from these functions.
-      state.value += 1
+      state.value += 1;
     },
     decrement: (state) => {
-      state.value -= 1
+      state.value -= 1;
     },
     incrementByAmount: (state, action) => {
-      state.value += action.payload
+      state.value += action.payload;
     },
   },
-})
+});
 
 // Action creators are generated for each case reducer function
-export const { increment, decrement, incrementByAmount } = counterSlice.actions
+export const { increment, decrement, incrementByAmount } = counterSlice.actions;
 
-export default counterSlice.reducer
+export default counterSlice.reducer;
 ```
 
 ### Add Slice Reducers to the Store
@@ -123,16 +122,16 @@ export default counterSlice.reducer
 Next, we need to import the reducer function from the counter slice and add it to our store. By defining a field inside the `reducer` parameter, we tell the store to use this slice reducer function to handle all updates to that state.
 
 ```js title="app/store.ts"
-import { configureStore } from '@reduxjs/toolkit'
+import { configureStore } from "@reduxjs/toolkit";
 // highlight-next-line
-import counterReducer from '../features/counter/counterSlice'
+import counterReducer from "../features/counter/counterSlice";
 
 export default configureStore({
   reducer: {
     // highlight-next-line
     counter: counterReducer,
   },
-})
+});
 ```
 
 ### Use Redux State and Actions in Angular Components
@@ -140,29 +139,25 @@ export default configureStore({
 Now we can use the Angular Redux inject functions to let Angular components interact with the Redux store. We can read data from the store with `useSelector`, and dispatch actions using `useDispatch`. Create a `src/features/counter/counter.component.ts` file with a `<app-counter>` component inside, then import that component into `app.component.ts` and render it inside of `<app-root>`.
 
 ```typescript title="features/counter/counter.component.ts"
-import { Component } from '@angular/core'
+import { Component } from "@angular/core";
 import { injectSelector, injectDispatch } from "@reduxjs/angular-redux";
-import { decrement, increment } from './store/counter-slice'
-import { RootState } from './store'
+import { decrement, increment } from "./store/counter-slice";
+import { RootState } from "./store";
 
 @Component({
-  selector: 'app-counter',
+  selector: "app-counter",
   standalone: true,
   template: `
-      <button (click)="dispatch(increment())">
-        Increment
-      </button>
-      <span>{{ count() }}</span>
-      <button (click)="dispatch(decrement())">
-        Decrement
-      </button>
-  `
+    <button (click)="dispatch(increment())">Increment</button>
+    <span>{{ count() }}</span>
+    <button (click)="dispatch(decrement())">Decrement</button>
+  `,
 })
 export class CounterComponent {
-  count = injectSelector((state: RootState) => state.counter.value)
-  dispatch = injectDispatch()
-  increment = increment
-  decrement = decrement
+  count = injectSelector((state: RootState) => state.counter.value);
+  dispatch = injectDispatch();
+  increment = increment;
+  decrement = decrement;
 }
 ```
 
diff --git a/docs/tutorials/typescript.md b/docs/tutorials/typescript.md
index 37df09a..795a77d 100644
--- a/docs/tutorials/typescript.md
+++ b/docs/tutorials/typescript.md
@@ -40,7 +40,7 @@ This page focuses on just how to set up the TypeScript aspects. For explanations
 Since those are types, it's safe to export them directly from your store setup file such as `app/store.ts` and import them directly into other files.
 
 ```ts title="app/store.ts"
-import { configureStore } from '@reduxjs/toolkit'
+import { configureStore } from "@reduxjs/toolkit";
 // ...
 
 const store = configureStore({
@@ -49,13 +49,13 @@ const store = configureStore({
     comments: commentsReducer,
     users: usersReducer,
   },
-})
+});
 
 // highlight-start
 // Infer the `RootState` and `AppDispatch` types from the store itself
-export type RootState = ReturnType<typeof store.getState>
+export type RootState = ReturnType<typeof store.getState>;
 // Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
-export type AppDispatch = typeof store.dispatch
+export type AppDispatch = typeof store.dispatch;
 // highlight-end
 ```
 
@@ -69,13 +69,13 @@ While it's possible to import the `RootState` and `AppDispatch` types into each
 Since these are actual variables, not types, it's important to define them in a separate file such as `app/injectables.ts`, not the store setup file. This allows you to import them into any component file that needs to use the injectables, and avoids potential circular import dependency issues.
 
 ```ts title="app/injectables.ts"
-import { injectDispatch, injectSelector } from '@reduxjs/angular-redux'
-import type { RootState, AppDispatch } from './store'
+import { injectDispatch, injectSelector } from "@reduxjs/angular-redux";
+import type { RootState, AppDispatch } from "./store";
 
 // highlight-start
 // Use throughout your app instead of plain `injectDispatch` and `injectSelector`
-export const injectAppDispatch = injectDispatch.withTypes<AppDispatch>()
-export const injectAppSelector = injectSelector.withTypes<RootState>()
+export const injectAppDispatch = injectDispatch.withTypes<AppDispatch>();
+export const injectAppSelector = injectSelector.withTypes<RootState>();
 // highlight-end
 ```
 
@@ -90,47 +90,47 @@ All generated actions should be defined using the `PayloadAction<T>` type from R
 You can safely import the `RootState` type from the store file here. It's a circular import, but the TypeScript compiler can correctly handle that for types. This may be needed for use cases like writing selector functions.
 
 ```ts title="features/counter/counterSlice.ts"
-import { createSlice, PayloadAction } from '@reduxjs/toolkit'
-import type { RootState } from '../../app/store'
+import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+import type { RootState } from "../../app/store";
 
 // highlight-start
 // Define a type for the slice state
 interface CounterState {
-  value: number
+  value: number;
 }
 
 // Define the initial state using that type
 const initialState: CounterState = {
   value: 0,
-}
+};
 // highlight-end
 
 export const counterSlice = createSlice({
-  name: 'counter',
+  name: "counter",
   // `createSlice` will infer the state type from the `initialState` argument
   initialState,
   reducers: {
     increment: (state) => {
-      state.value += 1
+      state.value += 1;
     },
     decrement: (state) => {
-      state.value -= 1
+      state.value -= 1;
     },
     // highlight-start
     // Use the PayloadAction type to declare the contents of `action.payload`
     incrementByAmount: (state, action: PayloadAction<number>) => {
       // highlight-end
-      state.value += action.payload
+      state.value += action.payload;
     },
   },
-})
+});
 
-export const { increment, decrement, incrementByAmount } = counterSlice.actions
+export const { increment, decrement, incrementByAmount } = counterSlice.actions;
 
 // Other code such as selectors can use the imported `RootState` type
-export const selectCount = (state: RootState) => state.counter.value
+export const selectCount = (state: RootState) => state.counter.value;
 
-export default counterSlice.reducer
+export default counterSlice.reducer;
 ```
 
 The generated action creators will be correctly typed to accept a `payload` argument based on the `PayloadAction<T>` type you provided for the reducer. For example, `incrementByAmount` requires a `number` as its argument.
@@ -141,7 +141,7 @@ In some cases, [TypeScript may unnecessarily tighten the type of the initial sta
 // Workaround: cast state instead of declaring variable type
 const initialState = {
   value: 0,
-} as CounterState
+} as CounterState;
 ```
 
 ### Use Typed Injectables in Components
@@ -149,23 +149,23 @@ const initialState = {
 In component files, import the pre-typed injectables instead of the standard injectables from Angular-Redux.
 
 ```typescript title="features/counter/counter.component.ts"
-import { Component } from '@angular/core'
+import { Component } from "@angular/core";
 // highlight-next-line
 import { injectAppSelector, injectAppDispatch } from "app/injectables";
-import { decrement, increment } from './store/counter-slice'
+import { decrement, increment } from "./store/counter-slice";
 
 @Component({
-  selector: 'app-counter',
+  selector: "app-counter",
   standalone: true,
   // omit rendering logic
 })
 export class CounterComponent {
   // highlight-start
   // The `state` arg is correctly typed as `RootState` already
-  count = injectAppSelector(state => state.counter.value)
-  dispatch = injectAppDispatch()
+  count = injectAppSelector((state) => state.counter.value);
+  dispatch = injectAppDispatch();
   // highlight-end
-  increment = increment
-  decrement = decrement
+  increment = increment;
+  decrement = decrement;
 }
 ```
diff --git a/package.json b/package.json
index c52b8d3..518bb1b 100644
--- a/package.json
+++ b/package.json
@@ -12,7 +12,9 @@
     "watch": "ng build --watch --configuration development",
     "test": "yarn test:ng && yarn test:schematics",
     "test:ng": "ng test",
-    "test:schematics": "cd projects/angular-redux/schematics && jest"
+    "test:schematics": "cd projects/angular-redux/schematics && jest",
+    "prettier": "prettier --ignore-unknown .",
+    "prettier:write": "yarn run prettier --write"
   },
   "workspaces": {
     "packages": [
@@ -53,6 +55,7 @@
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "ng-packagr": "^18.2.0",
+    "prettier": "^3.3.3",
     "ts-jest": "^29.2.5",
     "typescript": "~5.5.2"
   },
diff --git a/projects/angular-redux-demo/src/app/app.component.ts b/projects/angular-redux-demo/src/app/app.component.ts
index 9ade84f..069ae02 100644
--- a/projects/angular-redux-demo/src/app/app.component.ts
+++ b/projects/angular-redux-demo/src/app/app.component.ts
@@ -1,24 +1,20 @@
-import { Component } from '@angular/core'
-import { injectSelector, injectDispatch } from "@reduxjs/angular-redux";
-import { decrement, increment } from './store/counter-slice'
-import { RootState } from './store'
+import { Component } from '@angular/core';
+import { injectSelector, injectDispatch } from '@reduxjs/angular-redux';
+import { decrement, increment } from './store/counter-slice';
+import { RootState } from './store';
 
 @Component({
   selector: 'app-root',
   standalone: true,
   template: `
-      <button (click)="dispatch(increment())">
-        Increment
-      </button>
-      <span>{{ count() }}</span>
-      <button (click)="dispatch(decrement())">
-        Decrement
-      </button>
-  `
+    <button (click)="dispatch(increment())">Increment</button>
+    <span>{{ count() }}</span>
+    <button (click)="dispatch(decrement())">Decrement</button>
+  `,
 })
 export class AppComponent {
-  count = injectSelector((state: RootState) => state.counter.value)
-  dispatch = injectDispatch()
-  increment = increment
-  decrement = decrement
+  count = injectSelector((state: RootState) => state.counter.value);
+  dispatch = injectDispatch();
+  increment = increment;
+  decrement = decrement;
 }
diff --git a/projects/angular-redux-demo/src/app/app.config.ts b/projects/angular-redux-demo/src/app/app.config.ts
index e9227d3..067bab1 100644
--- a/projects/angular-redux-demo/src/app/app.config.ts
+++ b/projects/angular-redux-demo/src/app/app.config.ts
@@ -1,10 +1,10 @@
 import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
-import {provideRedux} from "angular-redux";
-import { store } from './store'
+import { provideRedux } from 'angular-redux';
+import { store } from './store';
 
 export const appConfig: ApplicationConfig = {
   providers: [
     provideZoneChangeDetection({ eventCoalescing: true }),
-    provideRedux({ store })
-  ]
+    provideRedux({ store }),
+  ],
 };
diff --git a/projects/angular-redux-demo/src/app/store/counter-slice.ts b/projects/angular-redux-demo/src/app/store/counter-slice.ts
index 01c3a9d..6f65718 100644
--- a/projects/angular-redux-demo/src/app/store/counter-slice.ts
+++ b/projects/angular-redux-demo/src/app/store/counter-slice.ts
@@ -1,13 +1,13 @@
-import { createSlice } from '@reduxjs/toolkit'
-import type { PayloadAction } from '@reduxjs/toolkit'
+import { createSlice } from '@reduxjs/toolkit';
+import type { PayloadAction } from '@reduxjs/toolkit';
 
 export interface CounterState {
-  value: number
+  value: number;
 }
 
 const initialState: CounterState = {
   value: 0,
-}
+};
 
 export const counterSlice = createSlice({
   name: 'counter',
@@ -18,18 +18,18 @@ export const counterSlice = createSlice({
       // doesn't actually mutate the state because it uses the Immer library,
       // which detects changes to a "draft state" and produces a brand new
       // immutable state based off those changes
-      state.value += 1
+      state.value += 1;
     },
     decrement: (state) => {
-      state.value -= 1
+      state.value -= 1;
     },
     incrementByAmount: (state, action: PayloadAction<number>) => {
-      state.value += action.payload
+      state.value += action.payload;
     },
   },
-})
+});
 
 // Action creators are generated for each case reducer function
-export const { increment, decrement, incrementByAmount } = counterSlice.actions
+export const { increment, decrement, incrementByAmount } = counterSlice.actions;
 
-export default counterSlice.reducer
+export default counterSlice.reducer;
diff --git a/projects/angular-redux-demo/src/app/store/index.ts b/projects/angular-redux-demo/src/app/store/index.ts
index 259ab6b..1f0c5e6 100644
--- a/projects/angular-redux-demo/src/app/store/index.ts
+++ b/projects/angular-redux-demo/src/app/store/index.ts
@@ -1,13 +1,13 @@
-import { configureStore } from '@reduxjs/toolkit'
-import counterReducer from './counter-slice'
+import { configureStore } from '@reduxjs/toolkit';
+import counterReducer from './counter-slice';
 
 export const store = configureStore({
   reducer: {
     counter: counterReducer,
   },
-})
+});
 
 // Infer the `RootState` and `AppDispatch` types from the store itself
-export type RootState = ReturnType<typeof store.getState>
+export type RootState = ReturnType<typeof store.getState>;
 // Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
-export type AppDispatch = typeof store.dispatch
+export type AppDispatch = typeof store.dispatch;
diff --git a/projects/angular-redux-demo/src/index.html b/projects/angular-redux-demo/src/index.html
index 8e65f1e..e0cbc09 100644
--- a/projects/angular-redux-demo/src/index.html
+++ b/projects/angular-redux-demo/src/index.html
@@ -1,13 +1,13 @@
 <!doctype html>
 <html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>AngularReduxDemo</title>
-  <base href="/">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <link rel="icon" type="image/x-icon" href="favicon.ico">
-</head>
-<body>
-  <app-root></app-root>
-</body>
+  <head>
+    <meta charset="utf-8" />
+    <title>AngularReduxDemo</title>
+    <base href="/" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="icon" type="image/x-icon" href="favicon.ico" />
+  </head>
+  <body>
+    <app-root></app-root>
+  </body>
 </html>
diff --git a/projects/angular-redux-demo/src/main.ts b/projects/angular-redux-demo/src/main.ts
index 35b00f3..8882c45 100644
--- a/projects/angular-redux-demo/src/main.ts
+++ b/projects/angular-redux-demo/src/main.ts
@@ -2,5 +2,6 @@ import { bootstrapApplication } from '@angular/platform-browser';
 import { appConfig } from './app/app.config';
 import { AppComponent } from './app/app.component';
 
-bootstrapApplication(AppComponent, appConfig)
-  .catch((err) => console.error(err));
+bootstrapApplication(AppComponent, appConfig).catch((err) =>
+  console.error(err),
+);
diff --git a/projects/angular-redux-demo/tsconfig.app.json b/projects/angular-redux-demo/tsconfig.app.json
index e40712b..3f672cc 100644
--- a/projects/angular-redux-demo/tsconfig.app.json
+++ b/projects/angular-redux-demo/tsconfig.app.json
@@ -6,10 +6,6 @@
     "outDir": "../../out-tsc/app",
     "types": []
   },
-  "files": [
-    "src/main.ts"
-  ],
-  "include": [
-    "src/**/*.d.ts"
-  ]
+  "files": ["src/main.ts"],
+  "include": ["src/**/*.d.ts"]
 }
diff --git a/projects/angular-redux/README.md b/projects/angular-redux/README.md
index 59f2aa3..94c5415 100644
--- a/projects/angular-redux/README.md
+++ b/projects/angular-redux/README.md
@@ -21,10 +21,10 @@ ng add @reduxjs/angular-redux@latest
 #### Optional `ng add` flags
 
 | flag          | description                                                                                                                                                                         | value type | default value |
-|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------|---------------
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- | ------------- |
 | `--path`      | Path to the module that you wish to add the import for the StoreModule to.                                                                                                          | `string`   |
 | `--project`   | Name of the project defined in your `angular.json` to help locating the module to add the `provideRedux` to.                                                                        | `string`   |
-| `--module`    | Name of file containing the module that you wish to add the import for the `provideRedux` to. Can also include the relative path to the file. For example, `src/app/app.module.ts`. | `string`   | `app`         
+| `--module`    | Name of file containing the module that you wish to add the import for the `provideRedux` to. Can also include the relative path to the file. For example, `src/app/app.module.ts`. | `string`   | `app`         |
 | `--storePath` | The file path to create the state in.                                                                                                                                               | `string`   | `store`       |
 
 This command will automate the following steps:
@@ -58,28 +58,24 @@ modules](https://webpack.js.org/api/module-methods/#commonjs).
 The following Angular component works as-expected:
 
 ```typescript
-import { Component } from '@angular/core'
+import { Component } from "@angular/core";
 import { injectSelector, injectDispatch } from "@reduxjs/angular-redux";
-import { decrement, increment } from './store/counter-slice'
-import { RootState } from './store'
+import { decrement, increment } from "./store/counter-slice";
+import { RootState } from "./store";
 
 @Component({
-  selector: 'app-root',
+  selector: "app-root",
   standalone: true,
   template: `
-      <button (click)="dispatch(increment())">
-        Increment
-      </button>
-      <span>{{ count() }}</span>
-      <button (click)="dispatch(decrement())">
-        Decrement
-      </button>
-  `
+    <button (click)="dispatch(increment())">Increment</button>
+    <span>{{ count() }}</span>
+    <button (click)="dispatch(decrement())">Decrement</button>
+  `,
 })
 export class AppComponent {
-  count = injectSelector((state: RootState) => state.counter.value)
-  dispatch = injectDispatch()
-  increment = increment
-  decrement = decrement
+  count = injectSelector((state: RootState) => state.counter.value);
+  dispatch = injectDispatch();
+  increment = increment;
+  decrement = decrement;
 }
 ```
diff --git a/projects/angular-redux/ng-package.json b/projects/angular-redux/ng-package.json
index c648dc8..e05d646 100644
--- a/projects/angular-redux/ng-package.json
+++ b/projects/angular-redux/ng-package.json
@@ -4,4 +4,4 @@
   "lib": {
     "entryFile": "src/public-api.ts"
   }
-}
\ No newline at end of file
+}
diff --git a/projects/angular-redux/schematics-core/index.ts b/projects/angular-redux/schematics-core/index.ts
index caf02f9..0716974 100644
--- a/projects/angular-redux/schematics-core/index.ts
+++ b/projects/angular-redux/schematics-core/index.ts
@@ -34,14 +34,11 @@ export {
   ReplaceChange,
   createReplaceChange,
   createChangeRecorder,
-  commitChanges
-} from './utility/change';
-export type {
-    Host,
-    Change
+  commitChanges,
 } from './utility/change';
+export type { Host, Change } from './utility/change';
 
-export {getWorkspace, getWorkspacePath} from './utility/config';
+export { getWorkspace, getWorkspacePath } from './utility/config';
 export type { AppConfig } from './utility/config';
 
 export { findComponentFromOptions } from './utility/find-component';
@@ -49,7 +46,7 @@ export { findComponentFromOptions } from './utility/find-component';
 export {
   findModule,
   findModuleFromOptions,
-  buildRelativePath
+  buildRelativePath,
 } from './utility/find-module';
 export type { ModuleOptions } from './utility/find-module';
 
diff --git a/projects/angular-redux/schematics-core/testing/create-app-module.ts b/projects/angular-redux/schematics-core/testing/create-app-module.ts
index ebf3b82..cef94db 100644
--- a/projects/angular-redux/schematics-core/testing/create-app-module.ts
+++ b/projects/angular-redux/schematics-core/testing/create-app-module.ts
@@ -2,7 +2,7 @@ import { UnitTestTree } from '@angular-devkit/schematics/testing';
 
 export function createAppModule(
   tree: UnitTestTree,
-  path?: string
+  path?: string,
 ): UnitTestTree {
   tree.create(
     path || '/src/app/app.module.ts',
@@ -22,7 +22,7 @@ export function createAppModule(
     bootstrap: [AppComponent]
     })
     export class AppModule { }
-  `
+  `,
   );
 
   return tree;
@@ -31,7 +31,7 @@ export function createAppModule(
 export function createAppModuleWithEffects(
   tree: UnitTestTree,
   path: string,
-  effects?: string
+  effects?: string,
 ): UnitTestTree {
   tree.create(
     path || '/src/app/app.module.ts',
@@ -53,7 +53,7 @@ export function createAppModuleWithEffects(
       bootstrap: [AppComponent]
     })
     export class AppModule { }
-  `
+  `,
   );
 
   return tree;
diff --git a/projects/angular-redux/schematics-core/testing/create-package.ts b/projects/angular-redux/schematics-core/testing/create-package.ts
index 23a5d50..343b314 100644
--- a/projects/angular-redux/schematics-core/testing/create-package.ts
+++ b/projects/angular-redux/schematics-core/testing/create-package.ts
@@ -11,7 +11,7 @@ export function createPackageJson(
   pkg: string,
   tree: UnitTestTree,
   version = '5.2.0',
-  packagePath = '/package.json'
+  packagePath = '/package.json',
 ) {
   tree.create(
     packagePath,
@@ -19,7 +19,7 @@ export function createPackageJson(
       "dependencies": {
         "@ngrx/${pkg}": "${prefix}${version}"
       }
-    }`
+    }`,
   );
 
   return tree;
diff --git a/projects/angular-redux/schematics-core/testing/create-reducers.ts b/projects/angular-redux/schematics-core/testing/create-reducers.ts
index 2ed0625..3778dc1 100644
--- a/projects/angular-redux/schematics-core/testing/create-reducers.ts
+++ b/projects/angular-redux/schematics-core/testing/create-reducers.ts
@@ -3,7 +3,7 @@ import { UnitTestTree } from '@angular-devkit/schematics/testing';
 export function createReducers(
   tree: UnitTestTree,
   path?: string,
-  project = 'bar'
+  project = 'bar',
 ) {
   tree.create(
     path || `/projects/${project}/src/app/reducers/index.ts`,
@@ -27,7 +27,7 @@ export function createReducers(
 
 
     export const metaReducers: MetaReducer<State>[] = isDevMode() ? [] : [];
-  `
+  `,
   );
 
   return tree;
diff --git a/projects/angular-redux/schematics-core/testing/create-workspace.ts b/projects/angular-redux/schematics-core/testing/create-workspace.ts
index c5526c2..f309011 100644
--- a/projects/angular-redux/schematics-core/testing/create-workspace.ts
+++ b/projects/angular-redux/schematics-core/testing/create-workspace.ts
@@ -26,7 +26,7 @@ const defaultLibOptions = {
 
 export function getTestProjectPath(
   workspaceOptions: any = defaultWorkspaceOptions,
-  appOptions: any = defaultAppOptions
+  appOptions: any = defaultAppOptions,
 ) {
   return `/${workspaceOptions.newProjectRoot}/${appOptions.name}`;
 }
@@ -36,33 +36,33 @@ export async function createWorkspace(
   appTree: UnitTestTree,
   workspaceOptions = defaultWorkspaceOptions,
   appOptions = defaultAppOptions,
-  libOptions = defaultLibOptions
+  libOptions = defaultLibOptions,
 ) {
   appTree = await schematicRunner.runExternalSchematic(
     '@schematics/angular',
     'workspace',
-    workspaceOptions
+    workspaceOptions,
   );
 
   appTree = await schematicRunner.runExternalSchematic(
     '@schematics/angular',
     'application',
     appOptions,
-    appTree
+    appTree,
   );
 
   appTree = await schematicRunner.runExternalSchematic(
     '@schematics/angular',
     'application',
     { ...appOptions, name: 'bar-standalone', standalone: true },
-    appTree
+    appTree,
   );
 
   appTree = await schematicRunner.runExternalSchematic(
     '@schematics/angular',
     'library',
     libOptions,
-    appTree
+    appTree,
   );
 
   return appTree;
diff --git a/projects/angular-redux/schematics-core/utility/ast-utils.ts b/projects/angular-redux/schematics-core/utility/ast-utils.ts
index 5f7475c..2441f08 100644
--- a/projects/angular-redux/schematics-core/utility/ast-utils.ts
+++ b/projects/angular-redux/schematics-core/utility/ast-utils.ts
@@ -28,7 +28,7 @@ import { Path } from '@angular-devkit/core';
 export function findNodes(
   node: ts.Node,
   kind: ts.SyntaxKind,
-  max = Infinity
+  max = Infinity,
 ): ts.Node[] {
   if (!node || max == 0) {
     return [];
@@ -106,7 +106,7 @@ export function insertAfterLastOccurrence(
   toInsert: string,
   file: string,
   fallbackPos: number,
-  syntaxKind?: ts.SyntaxKind
+  syntaxKind?: ts.SyntaxKind,
 ): Change {
   let lastItem = nodes.sort(nodesByPosition).pop();
   if (!lastItem) {
@@ -117,7 +117,7 @@ export function insertAfterLastOccurrence(
   }
   if (!lastItem && fallbackPos == undefined) {
     throw new Error(
-      `tried to insert ${toInsert} as first occurence with no fallback position`
+      `tried to insert ${toInsert} as first occurence with no fallback position`,
     );
   }
   const lastItemPosition: number = lastItem ? lastItem.end : fallbackPos;
@@ -127,7 +127,7 @@ export function insertAfterLastOccurrence(
 
 export function getContentOfKeyLiteral(
   _source: ts.SourceFile,
-  node: ts.Node
+  node: ts.Node,
 ): string | null {
   if (node.kind == ts.SyntaxKind.Identifier) {
     return (node as ts.Identifier).text;
@@ -140,7 +140,7 @@ export function getContentOfKeyLiteral(
 
 function _angularImportsFromNode(
   node: ts.ImportDeclaration,
-  _sourceFile: ts.SourceFile
+  _sourceFile: ts.SourceFile,
 ): { [name: string]: string } {
   const ms = node.moduleSpecifier;
   let modulePath: string;
@@ -173,7 +173,7 @@ function _angularImportsFromNode(
 
         return namedImports.elements
           .map((is: ts.ImportSpecifier) =>
-            is.propertyName ? is.propertyName.text : is.name.text
+            is.propertyName ? is.propertyName.text : is.name.text,
           )
           .reduce((acc: { [name: string]: string }, curr: string) => {
             acc[curr] = modulePath;
@@ -193,19 +193,19 @@ function _angularImportsFromNode(
 export function getDecoratorMetadata(
   source: ts.SourceFile,
   identifier: string,
-  module: string
+  module: string,
 ): ts.Node[] {
   const angularImports: { [name: string]: string } = findNodes(
     source,
-    ts.SyntaxKind.ImportDeclaration
+    ts.SyntaxKind.ImportDeclaration,
   )
     .map((node) =>
-      _angularImportsFromNode(node as ts.ImportDeclaration, source)
+      _angularImportsFromNode(node as ts.ImportDeclaration, source),
     )
     .reduce(
       (
         acc: { [name: string]: string },
-        current: { [name: string]: string }
+        current: { [name: string]: string },
       ) => {
         for (const key of Object.keys(current)) {
           acc[key] = current[key];
@@ -213,7 +213,7 @@ export function getDecoratorMetadata(
 
         return acc;
       },
-      {}
+      {},
     );
 
   return getSourceNodes(source)
@@ -253,7 +253,7 @@ export function getDecoratorMetadata(
     .filter(
       (expr) =>
         expr.arguments[0] &&
-        expr.arguments[0].kind == ts.SyntaxKind.ObjectLiteralExpression
+        expr.arguments[0].kind == ts.SyntaxKind.ObjectLiteralExpression,
     )
     .map((expr) => expr.arguments[0] as ts.ObjectLiteralExpression);
 }
@@ -263,7 +263,7 @@ function _addSymbolToNgModuleMetadata(
   ngModulePath: string,
   metadataField: string,
   symbolName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   const nodes = getDecoratorMetadata(source, 'NgModule', '@angular/core');
   let node: any = nodes[0]; // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -319,13 +319,13 @@ function _addSymbolToNgModuleMetadata(
     const newMetadataProperty = new InsertChange(
       ngModulePath,
       position,
-      toInsert
+      toInsert,
     );
     const newMetadataImport = insertImport(
       source,
       ngModulePath,
       symbolName.replace(/\..*$/, ''),
-      importPath
+      importPath,
     );
 
     return [newMetadataProperty, newMetadataImport];
@@ -348,7 +348,7 @@ function _addSymbolToNgModuleMetadata(
 
   if (!node) {
     console.log(
-      'No app module found. Please add your new class to your component.'
+      'No app module found. Please add your new class to your component.',
     );
 
     return [];
@@ -368,7 +368,7 @@ function _addSymbolToNgModuleMetadata(
         (node.getText().includes('EffectsModule.forRoot') &&
           symbolName.includes('EffectsModule.forRoot')) ||
         (node.getText().includes('EffectsModule.forFeature') &&
-          symbolName.includes('EffectsModule.forFeature'))
+          symbolName.includes('EffectsModule.forFeature')),
     );
 
     if (effectsModule && symbolName.includes('EffectsModule')) {
@@ -449,7 +449,7 @@ function _addSymbolToNgModuleMetadata(
     source,
     ngModulePath,
     symbolName.replace(/\..*$/, ''),
-    importPath
+    importPath,
   );
 
   return [insert, importInsert];
@@ -460,7 +460,7 @@ function _addSymbolToComponentMetadata(
   componentPath: string,
   metadataField: string,
   symbolName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   const nodes = getDecoratorMetadata(source, 'Component', '@angular/core');
   let node: any = nodes[0]; // eslint-disable-line @typescript-eslint/no-explicit-any
@@ -516,13 +516,13 @@ function _addSymbolToComponentMetadata(
     const newMetadataProperty = new InsertChange(
       componentPath,
       position,
-      toInsert
+      toInsert,
     );
     const newMetadataImport = insertImport(
       source,
       componentPath,
       symbolName.replace(/\..*$/, ''),
-      importPath
+      importPath,
     );
 
     return [newMetadataProperty, newMetadataImport];
@@ -545,7 +545,7 @@ function _addSymbolToComponentMetadata(
 
   if (!node) {
     console.log(
-      'No component found. Please add your new class to your component.'
+      'No component found. Please add your new class to your component.',
     );
 
     return [];
@@ -601,7 +601,7 @@ function _addSymbolToComponentMetadata(
     source,
     componentPath,
     symbolName.replace(/\..*$/, ''),
-    importPath
+    importPath,
   );
 
   return [insert, importInsert];
@@ -615,14 +615,14 @@ export function addDeclarationToModule(
   source: ts.SourceFile,
   modulePath: string,
   classifiedName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   return _addSymbolToNgModuleMetadata(
     source,
     modulePath,
     'declarations',
     classifiedName,
-    importPath
+    importPath,
   );
 }
 
@@ -634,14 +634,14 @@ export function addImportToModule(
   source: ts.SourceFile,
   modulePath: string,
   classifiedName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   return _addSymbolToNgModuleMetadata(
     source,
     modulePath,
     'imports',
     classifiedName,
-    importPath
+    importPath,
   );
 }
 
@@ -652,14 +652,14 @@ export function addProviderToModule(
   source: ts.SourceFile,
   modulePath: string,
   classifiedName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   return _addSymbolToNgModuleMetadata(
     source,
     modulePath,
     'providers',
     classifiedName,
-    importPath
+    importPath,
   );
 }
 
@@ -670,14 +670,14 @@ export function addProviderToComponent(
   source: ts.SourceFile,
   componentPath: string,
   classifiedName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   return _addSymbolToComponentMetadata(
     source,
     componentPath,
     'providers',
     classifiedName,
-    importPath
+    importPath,
   );
 }
 
@@ -688,14 +688,14 @@ export function addExportToModule(
   source: ts.SourceFile,
   modulePath: string,
   classifiedName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   return _addSymbolToNgModuleMetadata(
     source,
     modulePath,
     'exports',
     classifiedName,
-    importPath
+    importPath,
   );
 }
 
@@ -706,14 +706,14 @@ export function addBootstrapToModule(
   source: ts.SourceFile,
   modulePath: string,
   classifiedName: string,
-  importPath: string
+  importPath: string,
 ): Change[] {
   return _addSymbolToNgModuleMetadata(
     source,
     modulePath,
     'bootstrap',
     classifiedName,
-    importPath
+    importPath,
   );
 }
 
@@ -732,7 +732,7 @@ export function insertImport(
   fileToEdit: string,
   symbolName: string,
   fileName: string,
-  isDefault = false
+  isDefault = false,
 ): Change {
   const rootNode = source;
   const allImports = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
@@ -755,7 +755,7 @@ export function insertImport(
     relevantImports.forEach((n) => {
       Array.prototype.push.apply(
         imports,
-        findNodes(n, ts.SyntaxKind.Identifier)
+        findNodes(n, ts.SyntaxKind.Identifier),
       );
       if (findNodes(n, ts.SyntaxKind.AsteriskToken).length > 0) {
         importsAsterisk = true;
@@ -768,7 +768,7 @@ export function insertImport(
     }
 
     const importTextNodes = imports.filter(
-      (n) => (n as ts.Identifier).text === symbolName
+      (n) => (n as ts.Identifier).text === symbolName,
     );
 
     // insert import if it's not there
@@ -776,7 +776,7 @@ export function insertImport(
       const fallbackPos =
         findNodes(
           relevantImports[0],
-          ts.SyntaxKind.CloseBraceToken
+          ts.SyntaxKind.CloseBraceToken,
         )[0].getStart() ||
         findNodes(relevantImports[0], ts.SyntaxKind.FromKeyword)[0].getStart();
 
@@ -784,7 +784,7 @@ export function insertImport(
         imports,
         `, ${symbolName}`,
         fileToEdit,
-        fallbackPos
+        fallbackPos,
       );
     }
 
@@ -793,7 +793,7 @@ export function insertImport(
 
   // no such import declaration exists
   const useStrict = findNodes(rootNode, ts.SyntaxKind.StringLiteral).filter(
-    (n) => n.getText() === 'use strict'
+    (n) => n.getText() === 'use strict',
   );
   let fallbackPos = 0;
   if (useStrict.length > 0) {
@@ -813,7 +813,7 @@ export function insertImport(
     toInsert,
     fileToEdit,
     fallbackPos,
-    ts.SyntaxKind.StringLiteral
+    ts.SyntaxKind.StringLiteral,
   );
 }
 
@@ -822,14 +822,14 @@ export function replaceImport(
   path: Path,
   importFrom: string,
   importAsIs: string,
-  importToBe: string
+  importToBe: string,
 ): (ReplaceChange | RemoveChange)[] {
   const imports = sourceFile.statements
     .filter(ts.isImportDeclaration)
     .filter(
       ({ moduleSpecifier }) =>
         moduleSpecifier.getText(sourceFile) === `'${importFrom}'` ||
-        moduleSpecifier.getText(sourceFile) === `"${importFrom}"`
+        moduleSpecifier.getText(sourceFile) === `"${importFrom}"`,
     );
 
   if (imports.length === 0) {
@@ -874,7 +874,7 @@ export function replaceImport(
           sourceFile,
           specifier,
           importAsIs,
-          importToBe
+          importToBe,
         );
       }
 
@@ -885,7 +885,7 @@ export function replaceImport(
           sourceFile,
           specifier,
           specifier.getStart(sourceFile),
-          nextIdentifier.getStart(sourceFile)
+          nextIdentifier.getStart(sourceFile),
         );
       }
 
@@ -894,7 +894,7 @@ export function replaceImport(
         sourceFile,
         specifier,
         specifier.getStart(sourceFile),
-        specifier.getEnd()
+        specifier.getEnd(),
       );
     });
 
@@ -906,7 +906,7 @@ export function replaceImport(
 
 export function containsProperty(
   objectLiteral: ts.ObjectLiteralExpression,
-  propertyName: string
+  propertyName: string,
 ) {
   return (
     objectLiteral &&
@@ -914,7 +914,7 @@ export function containsProperty(
       (prop) =>
         ts.isPropertyAssignment(prop) &&
         ts.isIdentifier(prop.name) &&
-        prop.name.text === propertyName
+        prop.name.text === propertyName,
     )
   );
 }
diff --git a/projects/angular-redux/schematics-core/utility/change.ts b/projects/angular-redux/schematics-core/utility/change.ts
index 3b8ed0c..9981030 100644
--- a/projects/angular-redux/schematics-core/utility/change.ts
+++ b/projects/angular-redux/schematics-core/utility/change.ts
@@ -49,7 +49,11 @@ export class InsertChange implements Change {
   order: number;
   description: string;
 
-  constructor(public path: string, public pos: number, public toAdd: string) {
+  constructor(
+    public path: string,
+    public pos: number,
+    public toAdd: string,
+  ) {
     if (pos < 0) {
       throw new Error('Negative positions are invalid');
     }
@@ -77,7 +81,11 @@ export class RemoveChange implements Change {
   order: number;
   description: string;
 
-  constructor(public path: string, public pos: number, public end: number) {
+  constructor(
+    public path: string,
+    public pos: number,
+    public end: number,
+  ) {
     if (pos < 0 || end < 0) {
       throw new Error('Negative positions are invalid');
     }
@@ -107,7 +115,7 @@ export class ReplaceChange implements Change {
     public path: string,
     public pos: number,
     public oldText: string,
-    public newText: string
+    public newText: string,
   ) {
     if (pos < 0) {
       throw new Error('Negative positions are invalid');
@@ -124,7 +132,7 @@ export class ReplaceChange implements Change {
 
       if (text !== this.oldText) {
         return Promise.reject(
-          new Error(`Invalid replace: "${text}" != "${this.oldText}".`)
+          new Error(`Invalid replace: "${text}" != "${this.oldText}".`),
         );
       }
 
@@ -138,13 +146,13 @@ export function createReplaceChange(
   sourceFile: ts.SourceFile,
   node: ts.Node,
   oldText: string,
-  newText: string
+  newText: string,
 ): ReplaceChange {
   return new ReplaceChange(
     sourceFile.fileName,
     node.getStart(sourceFile),
     oldText,
-    newText
+    newText,
   );
 }
 
@@ -152,7 +160,7 @@ export function createRemoveChange(
   sourceFile: ts.SourceFile,
   node: ts.Node,
   from = node.getStart(sourceFile),
-  to = node.getEnd()
+  to = node.getEnd(),
 ): RemoveChange {
   return new RemoveChange(sourceFile.fileName, from, to);
 }
@@ -160,7 +168,7 @@ export function createRemoveChange(
 export function createChangeRecorder(
   tree: Tree,
   path: string,
-  changes: Change[]
+  changes: Change[],
 ): UpdateRecorder {
   const recorder = tree.beginUpdate(path);
   for (const change of changes) {
diff --git a/projects/angular-redux/schematics-core/utility/find-component.ts b/projects/angular-redux/schematics-core/utility/find-component.ts
index bb59ec3..fa94c4a 100644
--- a/projects/angular-redux/schematics-core/utility/find-component.ts
+++ b/projects/angular-redux/schematics-core/utility/find-component.ts
@@ -30,7 +30,7 @@ export interface ComponentOptions {
  */
 export function findComponentFromOptions(
   host: Tree,
-  options: ComponentOptions
+  options: ComponentOptions,
 ): Path | undefined {
   if (options.hasOwnProperty('skipImport') && options.skipImport) {
     return undefined;
@@ -44,7 +44,7 @@ export function findComponentFromOptions(
     return normalize(findComponent(host, pathToCheck));
   } else {
     const componentPath = normalize(
-      '/' + options.path + '/' + options.component
+      '/' + options.path + '/' + options.component,
     );
     const componentBaseName = normalize(componentPath).split('/').pop();
 
@@ -58,11 +58,11 @@ export function findComponentFromOptions(
       host.exists(componentPath + '/' + componentBaseName + '.component.ts')
     ) {
       return normalize(
-        componentPath + '/' + componentBaseName + '.component.ts'
+        componentPath + '/' + componentBaseName + '.component.ts',
       );
     } else {
       throw new Error(
-        `Specified component path ${componentPath} does not exist`
+        `Specified component path ${componentPath} does not exist`,
       );
     }
   }
@@ -84,7 +84,7 @@ export function findComponent(host: Tree, generateDir: string): Path {
     } else if (matches.length > 1) {
       throw new Error(
         'More than one component matches. Use skip-import option to skip importing ' +
-          'the component store into the closest component.'
+          'the component store into the closest component.',
       );
     }
 
@@ -93,7 +93,7 @@ export function findComponent(host: Tree, generateDir: string): Path {
 
   throw new Error(
     'Could not find an Component. Use the skip-import ' +
-      'option to skip importing in Component.'
+      'option to skip importing in Component.',
   );
 }
 
diff --git a/projects/angular-redux/schematics-core/utility/find-module.ts b/projects/angular-redux/schematics-core/utility/find-module.ts
index 134a59f..4b64ccf 100644
--- a/projects/angular-redux/schematics-core/utility/find-module.ts
+++ b/projects/angular-redux/schematics-core/utility/find-module.ts
@@ -30,7 +30,7 @@ export interface ModuleOptions {
  */
 export function findModuleFromOptions(
   host: Tree,
-  options: ModuleOptions
+  options: ModuleOptions,
 ): Path | undefined {
   if (options.hasOwnProperty('skipImport') && options.skipImport) {
     return undefined;
@@ -71,7 +71,7 @@ export function findModule(host: Tree, generateDir: string): Path {
 
   while (dir) {
     const matches = dir.subfiles.filter(
-      (p) => moduleRe.test(p) && !routingModuleRe.test(p)
+      (p) => moduleRe.test(p) && !routingModuleRe.test(p),
     );
 
     if (matches.length == 1) {
@@ -79,7 +79,7 @@ export function findModule(host: Tree, generateDir: string): Path {
     } else if (matches.length > 1) {
       throw new Error(
         'More than one module matches. Use skip-import option to skip importing ' +
-          'the component into the closest module.'
+          'the component into the closest module.',
       );
     }
 
@@ -88,7 +88,7 @@ export function findModule(host: Tree, generateDir: string): Path {
 
   throw new Error(
     'Could not find an NgModule. Use the skip-import ' +
-      'option to skip importing in NgModule.'
+      'option to skip importing in NgModule.',
   );
 }
 
diff --git a/projects/angular-redux/schematics-core/utility/json-utilts.ts b/projects/angular-redux/schematics-core/utility/json-utilts.ts
index be6b7b8..15c3af9 100644
--- a/projects/angular-redux/schematics-core/utility/json-utilts.ts
+++ b/projects/angular-redux/schematics-core/utility/json-utilts.ts
@@ -1,7 +1,7 @@
 // https://github.com/angular/angular-cli/blob/master/packages/schematics/angular/utility/json-utils.ts
 export function findPropertyInAstObject(
   node: any,
-  propertyName: string
+  propertyName: string,
 ): any | null {
   let maybeNode: any | null = null;
   for (const property of node.properties) {
diff --git a/projects/angular-redux/schematics-core/utility/package.ts b/projects/angular-redux/schematics-core/utility/package.ts
index 9ebbbed..3ea8899 100644
--- a/projects/angular-redux/schematics-core/utility/package.ts
+++ b/projects/angular-redux/schematics-core/utility/package.ts
@@ -7,7 +7,7 @@ export function addPackageToPackageJson(
   host: Tree,
   type: string,
   pkg: string,
-  version: string
+  version: string,
 ): Tree {
   if (host.exists('package.json')) {
     const sourceText = host.read('package.json')?.toString('utf-8') ?? '{}';
diff --git a/projects/angular-redux/schematics-core/utility/project.ts b/projects/angular-redux/schematics-core/utility/project.ts
index 36b546f..33c099c 100644
--- a/projects/angular-redux/schematics-core/utility/project.ts
+++ b/projects/angular-redux/schematics-core/utility/project.ts
@@ -13,7 +13,7 @@ export interface WorkspaceProject {
 
 export function getProject(
   host: Tree,
-  options: { project?: string | undefined; path?: string | undefined }
+  options: { project?: string | undefined; path?: string | undefined },
 ): WorkspaceProject {
   const workspace = getWorkspace(host);
 
@@ -31,7 +31,7 @@ export function getProject(
 
 export function getProjectPath(
   host: Tree,
-  options: { project?: string | undefined; path?: string | undefined }
+  options: { project?: string | undefined; path?: string | undefined },
 ) {
   const project = getProject(host, options);
 
@@ -51,7 +51,7 @@ export function getProjectPath(
 
 export function isLib(
   host: Tree,
-  options: { project?: string | undefined; path?: string | undefined }
+  options: { project?: string | undefined; path?: string | undefined },
 ) {
   const project = getProject(host, options);
 
@@ -60,7 +60,7 @@ export function isLib(
 
 export function getProjectMainFile(
   host: Tree,
-  options: { project?: string | undefined; path?: string | undefined }
+  options: { project?: string | undefined; path?: string | undefined },
 ) {
   if (isLib(host, options)) {
     throw new SchematicsException(`Invalid project type`);
diff --git a/projects/angular-redux/schematics-core/utility/standalone.ts b/projects/angular-redux/schematics-core/utility/standalone.ts
index f0e172c..64e54c1 100644
--- a/projects/angular-redux/schematics-core/utility/standalone.ts
+++ b/projects/angular-redux/schematics-core/utility/standalone.ts
@@ -29,7 +29,7 @@ interface ResolvedAppConfig {
 export function callsProvidersFunction(
   tree: Tree,
   filePath: string,
-  functionName: string
+  functionName: string,
 ): boolean {
   const sourceFile = createSourceFile(tree, filePath);
   const bootstrapCall = findBootstrapApplicationCall(sourceFile);
@@ -44,7 +44,7 @@ export function callsProvidersFunction(
     (el) =>
       ts.isCallExpression(el) &&
       ts.isIdentifier(el.expression) &&
-      el.expression.text === functionName
+      el.expression.text === functionName,
   );
 }
 
@@ -64,7 +64,7 @@ export function addFunctionalProvidersToStandaloneBootstrap(
   filePath: string,
   functionName: string,
   importPath: string,
-  args: ts.Expression[] = []
+  args: ts.Expression[] = [],
 ): string {
   const sourceFile = createSourceFile(tree, filePath);
   const bootstrapCall = findBootstrapApplicationCall(sourceFile);
@@ -78,14 +78,14 @@ export function addFunctionalProvidersToStandaloneBootstrap(
 
   if (!bootstrapCall) {
     throw new SchematicsException(
-      `Could not find bootstrapApplication call in ${filePath}`
+      `Could not find bootstrapApplication call in ${filePath}`,
     );
   }
 
   const providersCall = ts.factory.createCallExpression(
     ts.factory.createIdentifier(functionName),
     undefined,
-    args
+    args,
   );
 
   // If there's only one argument, we have to create a new object literal.
@@ -113,7 +113,7 @@ export function addFunctionalProvidersToStandaloneBootstrap(
 
   if (!appConfig) {
     throw new SchematicsException(
-      `Could not statically analyze config in bootstrapApplication call in ${filePath}`
+      `Could not statically analyze config in bootstrapApplication call in ${filePath}`,
     );
   }
 
@@ -142,12 +142,12 @@ export function addFunctionalProvidersToStandaloneBootstrap(
  * `@schematics/angular/utility` instead.
  */
 export function findBootstrapApplicationCall(
-  sourceFile: ts.SourceFile
+  sourceFile: ts.SourceFile,
 ): ts.CallExpression | null {
   const localName = findImportLocalName(
     sourceFile,
     'bootstrapApplication',
-    '@angular/platform-browser'
+    '@angular/platform-browser',
   );
 
   if (!localName) {
@@ -175,7 +175,7 @@ export function findBootstrapApplicationCall(
 
 /** Finds the `providers` array literal within an application config. */
 function findProvidersLiteral(
-  config: ts.ObjectLiteralExpression
+  config: ts.ObjectLiteralExpression,
 ): ts.ArrayLiteralExpression | null {
   for (const prop of config.properties) {
     if (
@@ -200,7 +200,7 @@ function findProvidersLiteral(
 function findAppConfig(
   bootstrapCall: ts.CallExpression,
   tree: Tree,
-  filePath: string
+  filePath: string,
 ): ResolvedAppConfig | null {
   if (bootstrapCall.arguments.length > 1) {
     const config = bootstrapCall.arguments[1];
@@ -226,7 +226,7 @@ function findAppConfig(
 function resolveAppConfigFromIdentifier(
   identifier: ts.Identifier,
   tree: Tree,
-  bootstapFilePath: string
+  bootstapFilePath: string,
 ): ResolvedAppConfig | null {
   const sourceFile = identifier.getSourceFile();
 
@@ -254,12 +254,12 @@ function resolveAppConfigFromIdentifier(
       // operate on individual files, not the entire program.
       const filePath = join(
         dirname(bootstapFilePath),
-        node.moduleSpecifier.text + '.ts'
+        node.moduleSpecifier.text + '.ts',
       );
       const importedSourceFile = createSourceFile(tree, filePath);
       const resolvedVariable = findAppConfigFromVariableName(
         importedSourceFile,
-        (specifier.propertyName || specifier.name).text
+        (specifier.propertyName || specifier.name).text,
       );
 
       if (resolvedVariable) {
@@ -270,7 +270,7 @@ function resolveAppConfigFromIdentifier(
 
   const variableInSameFile = findAppConfigFromVariableName(
     sourceFile,
-    identifier.text
+    identifier.text,
   );
 
   return variableInSameFile
@@ -285,7 +285,7 @@ function resolveAppConfigFromIdentifier(
  */
 function findAppConfigFromVariableName(
   sourceFile: ts.SourceFile,
-  variableName: string
+  variableName: string,
 ): ts.ObjectLiteralExpression | null {
   for (const node of sourceFile.statements) {
     if (ts.isVariableStatement(node)) {
@@ -314,7 +314,7 @@ function findAppConfigFromVariableName(
 function findImportLocalName(
   sourceFile: ts.SourceFile,
   name: string,
-  moduleName: string
+  moduleName: string,
 ): string | null {
   for (const node of sourceFile.statements) {
     // Only look for top-level imports.
@@ -353,7 +353,7 @@ function createSourceFile(tree: Tree, filePath: string): ts.SourceFile {
     filePath,
     tree.readText(filePath),
     ts.ScriptTarget.Latest,
-    true
+    true,
   );
 }
 
@@ -366,7 +366,7 @@ function createSourceFile(tree: Tree, filePath: string): ts.SourceFile {
 function addNewAppConfigToCall(
   call: ts.CallExpression,
   expression: ts.Expression,
-  recorder: UpdateRecorder
+  recorder: UpdateRecorder,
 ): void {
   const newCall = ts.factory.updateCallExpression(
     call,
@@ -378,12 +378,12 @@ function addNewAppConfigToCall(
         [
           ts.factory.createPropertyAssignment(
             'providers',
-            ts.factory.createArrayLiteralExpression([expression])
+            ts.factory.createArrayLiteralExpression([expression]),
           ),
         ],
-        true
+        true,
       ),
-    ]
+    ],
   );
 
   recorder.remove(call.getStart(), call.getWidth());
@@ -391,7 +391,7 @@ function addNewAppConfigToCall(
     call.getStart(),
     ts
       .createPrinter()
-      .printNode(ts.EmitHint.Unspecified, newCall, call.getSourceFile())
+      .printNode(ts.EmitHint.Unspecified, newCall, call.getSourceFile()),
   );
 }
 
@@ -404,7 +404,7 @@ function addNewAppConfigToCall(
 function addElementToArray(
   node: ts.ArrayLiteralExpression,
   element: ts.Expression,
-  recorder: UpdateRecorder
+  recorder: UpdateRecorder,
 ): void {
   const newLiteral = ts.factory.updateArrayLiteralExpression(node, [
     ...node.elements,
@@ -415,7 +415,7 @@ function addElementToArray(
     node.getStart(),
     ts
       .createPrinter()
-      .printNode(ts.EmitHint.Unspecified, newLiteral, node.getSourceFile())
+      .printNode(ts.EmitHint.Unspecified, newLiteral, node.getSourceFile()),
   );
 }
 
@@ -428,13 +428,13 @@ function addElementToArray(
 function addProvidersToObjectLiteral(
   node: ts.ObjectLiteralExpression,
   expression: ts.Expression,
-  recorder: UpdateRecorder
+  recorder: UpdateRecorder,
 ) {
   const newOptionsLiteral = ts.factory.updateObjectLiteralExpression(node, [
     ...node.properties,
     ts.factory.createPropertyAssignment(
       'providers',
-      ts.factory.createArrayLiteralExpression([expression])
+      ts.factory.createArrayLiteralExpression([expression]),
     ),
   ]);
   recorder.remove(node.getStart(), node.getWidth());
@@ -445,8 +445,8 @@ function addProvidersToObjectLiteral(
       .printNode(
         ts.EmitHint.Unspecified,
         newOptionsLiteral,
-        node.getSourceFile()
-      )
+        node.getSourceFile(),
+      ),
   );
 }
 
@@ -459,7 +459,7 @@ function isMergeAppConfigCall(node: ts.Node): node is ts.CallExpression {
   const localName = findImportLocalName(
     node.getSourceFile(),
     'mergeApplicationConfig',
-    '@angular/core'
+    '@angular/core',
   );
 
   return (
diff --git a/projects/angular-redux/schematics-core/utility/strings.ts b/projects/angular-redux/schematics-core/utility/strings.ts
index 38e9924..269ece9 100644
--- a/projects/angular-redux/schematics-core/utility/strings.ts
+++ b/projects/angular-redux/schematics-core/utility/strings.ts
@@ -56,7 +56,7 @@ export function camelize(str: string): string {
       STRING_CAMELIZE_REGEXP,
       (_match: string, _separator: string, chr: string) => {
         return chr ? chr.toUpperCase() : '';
-      }
+      },
     )
     .replace(/^([A-Z])/, (match: string) => match.toLowerCase());
 }
@@ -124,8 +124,8 @@ export function capitalize(str: string): string {
 export function pluralize(str: string): string {
   return camelize(
     [/([^aeiou])y$/, /()fe?$/, /([^aeiou]o|[sxz]|[cs]h)$/].map(
-      (c, i) => (str = str.replace(c, `$1${'iv'[i] || ''}e`))
-    ) && str + 's'
+      (c, i) => (str = str.replace(c, `$1${'iv'[i] || ''}e`)),
+    ) && str + 's',
   );
 }
 
@@ -137,7 +137,7 @@ export function featurePath(
   group: boolean | undefined,
   flat: boolean | undefined,
   path: string,
-  name: string
+  name: string,
 ) {
   if (group && !flat) {
     return `../../${path}/${name}/`;
diff --git a/projects/angular-redux/schematics-core/utility/visitors.ts b/projects/angular-redux/schematics-core/utility/visitors.ts
index fa4edd0..090dfa2 100644
--- a/projects/angular-redux/schematics-core/utility/visitors.ts
+++ b/projects/angular-redux/schematics-core/utility/visitors.ts
@@ -7,8 +7,8 @@ export function visitTSSourceFiles<Result = void>(
   visitor: (
     sourceFile: ts.SourceFile,
     tree: Tree,
-    result?: Result
-  ) => Result | undefined
+    result?: Result,
+  ) => Result | undefined,
 ): Result | undefined {
   let result: Result | undefined = undefined;
   for (const sourceFile of visit(tree.root)) {
@@ -27,8 +27,8 @@ export function visitTemplates(
       inline: boolean;
       start: number;
     },
-    tree: Tree
-  ) => void
+    tree: Tree,
+  ) => void,
 ): void {
   visitTSSourceFiles(tree, (source) => {
     visitComponents(source, (_, decoratorExpressionNode) => {
@@ -48,7 +48,7 @@ export function visitTemplates(
                 inline: true,
                 start: templateStartIdx,
               },
-              tree
+              tree,
             );
             return;
           } else if (
@@ -58,7 +58,7 @@ export function visitTemplates(
             const parts = normalize(source.fileName).split('/').slice(0, -1);
             const templatePath = resolve(
               normalize(parts.join('/')),
-              normalize(n.initializer.text)
+              normalize(n.initializer.text),
             );
             if (!tree.exists(templatePath)) {
               return;
@@ -76,7 +76,7 @@ export function visitTemplates(
                 inline: false,
                 start: 0,
               },
-              tree
+              tree,
             );
             return;
           }
@@ -92,8 +92,8 @@ export function visitNgModuleImports(
   sourceFile: ts.SourceFile,
   callback: (
     importNode: ts.PropertyAssignment,
-    elementExpressions: ts.NodeArray<ts.Expression>
-  ) => void
+    elementExpressions: ts.NodeArray<ts.Expression>,
+  ) => void,
 ) {
   visitNgModuleProperty(sourceFile, callback, 'imports');
 }
@@ -102,8 +102,8 @@ export function visitNgModuleExports(
   sourceFile: ts.SourceFile,
   callback: (
     exportNode: ts.PropertyAssignment,
-    elementExpressions: ts.NodeArray<ts.Expression>
-  ) => void
+    elementExpressions: ts.NodeArray<ts.Expression>,
+  ) => void,
 ) {
   visitNgModuleProperty(sourceFile, callback, 'exports');
 }
@@ -112,9 +112,9 @@ function visitNgModuleProperty(
   sourceFile: ts.SourceFile,
   callback: (
     nodes: ts.PropertyAssignment,
-    elementExpressions: ts.NodeArray<ts.Expression>
+    elementExpressions: ts.NodeArray<ts.Expression>,
   ) => void,
-  property: string
+  property: string,
 ) {
   visitNgModules(sourceFile, (_, decoratorExpressionNode) => {
     ts.forEachChild(decoratorExpressionNode, function findTemplates(n) {
@@ -136,8 +136,8 @@ export function visitComponents(
   sourceFile: ts.SourceFile,
   callback: (
     classDeclarationNode: ts.ClassDeclaration,
-    decoratorExpressionNode: ts.ObjectLiteralExpression
-  ) => void
+    decoratorExpressionNode: ts.ObjectLiteralExpression,
+  ) => void,
 ) {
   visitDecorator(sourceFile, 'Component', callback);
 }
@@ -146,8 +146,8 @@ export function visitNgModules(
   sourceFile: ts.SourceFile,
   callback: (
     classDeclarationNode: ts.ClassDeclaration,
-    decoratorExpressionNode: ts.ObjectLiteralExpression
-  ) => void
+    decoratorExpressionNode: ts.ObjectLiteralExpression,
+  ) => void,
 ) {
   visitDecorator(sourceFile, 'NgModule', callback);
 }
@@ -157,8 +157,8 @@ export function visitDecorator(
   decoratorName: string,
   callback: (
     classDeclarationNode: ts.ClassDeclaration,
-    decoratorExpressionNode: ts.ObjectLiteralExpression
-  ) => void
+    decoratorExpressionNode: ts.ObjectLiteralExpression,
+  ) => void,
 ) {
   ts.forEachChild(sourceFile, function findClassDeclaration(node) {
     if (!ts.isClassDeclaration(node)) {
@@ -208,7 +208,7 @@ function* visit(directory: DirEntry): IterableIterator<ts.SourceFile> {
           entry.path,
           content.toString().replace(/^\uFEFF/, ''),
           ts.ScriptTarget.Latest,
-          true
+          true,
         );
         yield source;
       }
diff --git a/projects/angular-redux/schematics/jest.config.mjs b/projects/angular-redux/schematics/jest.config.mjs
index 991c5fc..d3bbf98 100644
--- a/projects/angular-redux/schematics/jest.config.mjs
+++ b/projects/angular-redux/schematics/jest.config.mjs
@@ -1,13 +1,13 @@
 export default {
-  displayName: 'Schematics',
-  coverageDirectory: '../../coverage/modules/schematics',
+  displayName: "Schematics",
+  coverageDirectory: "../../coverage/modules/schematics",
   transform: {
-    '^.+\\.(ts|mjs|js)$': [
-      'ts-jest',
+    "^.+\\.(ts|mjs|js)$": [
+      "ts-jest",
       {
-        tsconfig: '<rootDir>/tsconfig.spec.json'
+        tsconfig: "<rootDir>/tsconfig.spec.json",
       },
     ],
   },
-  transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)']
+  transformIgnorePatterns: ["node_modules/(?!.*\\.mjs$)"],
 };
diff --git a/projects/angular-redux/schematics/ng-add/index.spec.ts b/projects/angular-redux/schematics/ng-add/index.spec.ts
index 24e0312..6055b73 100644
--- a/projects/angular-redux/schematics/ng-add/index.spec.ts
+++ b/projects/angular-redux/schematics/ng-add/index.spec.ts
@@ -12,12 +12,12 @@ import {
 describe('Store ng-add Schematic', () => {
   const schematicRunner = new SchematicTestRunner(
     '@reduxjs/angular-redux',
-    path.join(__dirname, '../collection.json')
+    path.join(__dirname, '../collection.json'),
   );
   const defaultOptions: AngularReduxOptions = {
     skipPackageJson: false,
     project: 'bar',
-    module: 'app'
+    module: 'app',
   };
 
   const projectPath = getTestProjectPath();
@@ -56,7 +56,7 @@ describe('Store ng-add Schematic', () => {
     const tree = await schematicRunner.runSchematic('ng-add', options, appTree);
     const files = tree.files;
     expect(
-      files.indexOf(`${projectPath}/src/app/store/index.ts`)
+      files.indexOf(`${projectPath}/src/app/store/index.ts`),
     ).toBeGreaterThanOrEqual(0);
   });
 
@@ -65,9 +65,7 @@ describe('Store ng-add Schematic', () => {
 
     const tree = await schematicRunner.runSchematic('ng-add', options, appTree);
     const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
-    expect(content).toMatch(
-      /import { store } from '\.\/store';/
-    );
+    expect(content).toMatch(/import { store } from '\.\/store';/);
   });
 
   it('should fail if specified module does not exist', async () => {
@@ -95,18 +93,16 @@ describe('Store ng-add Schematic', () => {
       const tree = await schematicRunner.runSchematic(
         'ng-add',
         options,
-        appTree
+        appTree,
       );
 
       const content = tree.readContent(`${projectPath}/src/app/app.config.ts`);
       const files = tree.files;
 
       expect(content).toMatch(/provideRedux\(\{ store \}\)/);
-      expect(content).toMatch(
-        /import { store } from '\.\/store';/
-      );
+      expect(content).toMatch(/import { store } from '\.\/store';/);
       expect(files.indexOf(`${projectPath}/src/app/store/index.ts`)).not.toBe(
-        -1
+        -1,
       );
     });
   });
diff --git a/projects/angular-redux/schematics/ng-add/index.ts b/projects/angular-redux/schematics/ng-add/index.ts
index c17cda2..eef64fa 100644
--- a/projects/angular-redux/schematics/ng-add/index.ts
+++ b/projects/angular-redux/schematics/ng-add/index.ts
@@ -1,5 +1,5 @@
-import * as fs from "fs";
-import * as path from "path";
+import * as fs from 'fs';
+import * as path from 'path';
 import * as ts from 'typescript';
 import {
   Rule,
@@ -61,7 +61,7 @@ function addImportToNgModule(options: AngularReduxOptions): Rule {
       modulePath,
       sourceText,
       ts.ScriptTarget.Latest,
-      true
+      true,
     );
 
     const storeModuleSetup = `provideRedux({store: store})`;
@@ -72,11 +72,16 @@ function addImportToNgModule(options: AngularReduxOptions): Rule {
       source,
       modulePath,
       storeModuleSetup,
-      relativePath
+      relativePath,
     );
 
     let changes = [
-      insertImport(source, modulePath, 'provideRedux', '@reduxjs/angular-redux'),
+      insertImport(
+        source,
+        modulePath,
+        'provideRedux',
+        '@reduxjs/angular-redux',
+      ),
       insertImport(source, modulePath, 'store', relativePath),
       storeNgModuleImport,
     ];
@@ -94,11 +99,13 @@ function addImportToNgModule(options: AngularReduxOptions): Rule {
   };
 }
 
-const angularReduxPackageMeta = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), "utf8")) as unknown as {
+const angularReduxPackageMeta = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'),
+) as unknown as {
   version: string;
   peerDependencies: {
     [key: string]: string;
-  }
+  };
 };
 
 function addReduxDepsToPackageJson() {
@@ -107,19 +114,19 @@ function addReduxDepsToPackageJson() {
       host,
       'dependencies',
       '@reduxjs/toolkit',
-      angularReduxPackageMeta.peerDependencies['@reduxjs/toolkit']
+      angularReduxPackageMeta.peerDependencies['@reduxjs/toolkit'],
     );
     addPackageToPackageJson(
       host,
       'dependencies',
       'redux',
-      angularReduxPackageMeta.peerDependencies['redux']
+      angularReduxPackageMeta.peerDependencies['redux'],
     );
     addPackageToPackageJson(
       host,
       'dependencies',
       '@reduxjs/angular-redux',
-      angularReduxPackageMeta.version
+      angularReduxPackageMeta.version,
     );
     context.addTask(new NodePackageInstallTask());
     return host;
@@ -137,15 +144,13 @@ function addStandaloneConfig(options: AngularReduxOptions): Rule {
         // exit because the store config is already provided
         return host;
       }
-      const storeProviderOptions =  [
-        ts.factory.createIdentifier('{ store }'),
-      ];
+      const storeProviderOptions = [ts.factory.createIdentifier('{ store }')];
       const patchedConfigFile = addFunctionalProvidersToStandaloneBootstrap(
         host,
         mainFile,
         storeProviderFn,
         '@reduxjs/angular-redux',
-        storeProviderOptions
+        storeProviderOptions,
       );
 
       // insert reducers import into the patched file
@@ -154,12 +159,12 @@ function addStandaloneConfig(options: AngularReduxOptions): Rule {
         patchedConfigFile,
         configFileContent?.toString('utf-8') || '',
         ts.ScriptTarget.Latest,
-        true
+        true,
       );
       const statePath = `/${options.path}/${options.storePath}`;
       const relativePath = buildRelativePath(
         `/${patchedConfigFile}`,
-        statePath
+        statePath,
       );
 
       const recorder = host.beginUpdate(patchedConfigFile);
@@ -168,7 +173,7 @@ function addStandaloneConfig(options: AngularReduxOptions): Rule {
         source,
         patchedConfigFile,
         'store',
-        relativePath
+        relativePath,
       );
 
       if (change instanceof InsertChange) {
@@ -180,7 +185,7 @@ function addStandaloneConfig(options: AngularReduxOptions): Rule {
       return host;
     }
     throw new SchematicsException(
-      `Main file not found for a project ${options.project}`
+      `Main file not found for a project ${options.project}`,
     );
   };
 }
diff --git a/projects/angular-redux/schematics/tsconfig.spec.json b/projects/angular-redux/schematics/tsconfig.spec.json
index 445ce27..424e87e 100644
--- a/projects/angular-redux/schematics/tsconfig.spec.json
+++ b/projects/angular-redux/schematics/tsconfig.spec.json
@@ -3,13 +3,7 @@
   "compilerOptions": {
     "outDir": "../../out-tsc/spec",
     "emitDecoratorMetadata": true,
-    "types": [
-      "jest",
-      "node"
-    ]
+    "types": ["jest", "node"]
   },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.d.ts"
-  ]
+  "include": ["**/*.spec.ts", "**/*.d.ts"]
 }
diff --git a/projects/angular-redux/src/lib/inject-dispatch.ts b/projects/angular-redux/src/lib/inject-dispatch.ts
index 4c03eae..66a4817 100644
--- a/projects/angular-redux/src/lib/inject-dispatch.ts
+++ b/projects/angular-redux/src/lib/inject-dispatch.ts
@@ -1,7 +1,6 @@
-import type { Dispatch, UnknownAction, Action } from 'redux'
-import { assertInInjectionContext } from '@angular/core'
-import { injectStore } from './inject-store'
-
+import type { Dispatch, UnknownAction, Action } from 'redux';
+import { assertInInjectionContext } from '@angular/core';
+import { injectStore } from './inject-store';
 
 /**
  * Represents a custom injection that provides a dispatch function
@@ -21,7 +20,7 @@ export interface InjectDispatch<
    *
    * @template AppDispatch - The specific type of the dispatch function.
    */
-    <AppDispatch extends DispatchType = DispatchType>(): AppDispatch
+  <AppDispatch extends DispatchType = DispatchType>(): AppDispatch;
 
   /**
    * Creates a "pre-typed" version of {@linkcode injectDispatch injectDispatch}
@@ -41,7 +40,7 @@ export interface InjectDispatch<
    */
   withTypes: <
     OverrideDispatchType extends DispatchType,
-  >() => InjectDispatch<OverrideDispatchType>
+  >() => InjectDispatch<OverrideDispatchType>;
 }
 
 /**
@@ -52,17 +51,19 @@ export interface InjectDispatch<
 export function createDispatchInjection<
   ActionType extends Action = UnknownAction,
 >() {
-  const injectDispatch = <AppDispatch extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>(): AppDispatch  => {
-    assertInInjectionContext(injectDispatch)
+  const injectDispatch = <
+    AppDispatch extends Dispatch<UnknownAction> = Dispatch<UnknownAction>,
+  >(): AppDispatch => {
+    assertInInjectionContext(injectDispatch);
     const store = injectStore();
-    return store.dispatch as AppDispatch
-  }
+    return store.dispatch as AppDispatch;
+  };
 
   Object.assign(injectDispatch, {
     withTypes: () => injectDispatch,
-  })
+  });
 
-  return injectDispatch as InjectDispatch<Dispatch<ActionType>>
+  return injectDispatch as InjectDispatch<Dispatch<ActionType>>;
 }
 
 /**
@@ -88,4 +89,4 @@ export function createDispatchInjection<
  *   increaseCounter = () => dispatch({ type: 'increase-counter' })
  * }
  */
-export const injectDispatch = /* #__PURE__*/ createDispatchInjection()
+export const injectDispatch = /* #__PURE__*/ createDispatchInjection();
diff --git a/projects/angular-redux/src/lib/inject-selector.ts b/projects/angular-redux/src/lib/inject-selector.ts
index e3fbc06..b634768 100644
--- a/projects/angular-redux/src/lib/inject-selector.ts
+++ b/projects/angular-redux/src/lib/inject-selector.ts
@@ -1,12 +1,18 @@
-import { EqualityFn } from './types'
-import { assertInInjectionContext, effect, inject, Signal, signal } from '@angular/core'
-import { ReduxProvider } from './provider'
+import { EqualityFn } from './types';
+import {
+  assertInInjectionContext,
+  effect,
+  inject,
+  Signal,
+  signal,
+} from '@angular/core';
+import { ReduxProvider } from './provider';
 
 export interface InjectSelectorOptions<Selected = unknown> {
-  equalityFn?: EqualityFn<Selected>
+  equalityFn?: EqualityFn<Selected>;
 }
 
-const refEquality: EqualityFn<any> = (a, b) => a === b
+const refEquality: EqualityFn<any> = (a, b) => a === b;
 
 /**
  * Represents a custom injection that allows you to extract data from the
@@ -32,10 +38,12 @@ export interface InjectSelector<StateType = unknown> {
    * @template TState - The specific type of state this injection operates on.
    * @template Selected - The type of the value that the selector function will return.
    */
-    <TState extends StateType = StateType, Selected = unknown>(
+  <TState extends StateType = StateType, Selected = unknown>(
     selector: (state: TState) => Selected,
-    equalityFnOrOptions?: EqualityFn<Selected> | InjectSelectorOptions<Selected>,
-  ): Signal<Selected>
+    equalityFnOrOptions?:
+      | EqualityFn<Selected>
+      | InjectSelectorOptions<Selected>,
+  ): Signal<Selected>;
 
   /**
    * Creates a "pre-typed" version of {@linkcode injectSelector injectSelector}
@@ -55,7 +63,7 @@ export interface InjectSelector<StateType = unknown> {
    */
   withTypes: <
     OverrideStateType extends StateType,
-  >() => InjectSelector<OverrideStateType>
+  >() => InjectSelector<OverrideStateType>;
 }
 
 /**
@@ -64,50 +72,47 @@ export interface InjectSelector<StateType = unknown> {
  * @returns {Function} A `injectSelector` injection bound to the specified context.
  */
 export function createSelectorInjection(): InjectSelector {
-  const injectSelector =
-  <TState, Selected>(
+  const injectSelector = <TState, Selected>(
     selector: (state: TState) => Selected,
-    equalityFnOrOptions: EqualityFn<Selected> | InjectSelectorOptions<Selected> = {},
-  ): Signal<Selected> =>
-  {
-    assertInInjectionContext(injectSelector)
+    equalityFnOrOptions:
+      | EqualityFn<Selected>
+      | InjectSelectorOptions<Selected> = {},
+  ): Signal<Selected> => {
+    assertInInjectionContext(injectSelector);
     const reduxContext = inject(ReduxProvider);
 
     const { equalityFn = refEquality } =
       typeof equalityFnOrOptions === 'function'
         ? { equalityFn: equalityFnOrOptions }
-        : equalityFnOrOptions
+        : equalityFnOrOptions;
 
-    const {
-      store,
-      subscription
-    } = reduxContext
+    const { store, subscription } = reduxContext;
 
-    const selectedState = signal(selector(store.getState()))
+    const selectedState = signal(selector(store.getState()));
 
     effect((onCleanup) => {
       const unsubscribe = subscription.addNestedSub(() => {
         const data = selector(store.getState());
         if (equalityFn(selectedState(), data)) {
-          return
+          return;
         }
 
         selectedState.set(data);
-      })
+      });
 
       onCleanup(() => {
-        unsubscribe()
-      })
-    })
+        unsubscribe();
+      });
+    });
 
-    return selectedState
-  }
+    return selectedState;
+  };
 
   Object.assign(injectSelector, {
     withTypes: () => injectSelector,
-  })
+  });
 
-  return injectSelector as InjectSelector
+  return injectSelector as InjectSelector;
 }
 
 /**
@@ -135,4 +140,4 @@ export function createSelectorInjection(): InjectSelector {
  *   counter = injectSelector(state => state.counter)
  * }
  */
-export const injectSelector = /* #__PURE__*/ createSelectorInjection()
+export const injectSelector = /* #__PURE__*/ createSelectorInjection();
diff --git a/projects/angular-redux/src/lib/inject-store.ts b/projects/angular-redux/src/lib/inject-store.ts
index d6c1f98..08b0240 100644
--- a/projects/angular-redux/src/lib/inject-store.ts
+++ b/projects/angular-redux/src/lib/inject-store.ts
@@ -1,6 +1,6 @@
-import { assertInInjectionContext, inject } from '@angular/core'
-import { ReduxProvider } from './provider'
-import type { Store, Action } from 'redux'
+import { assertInInjectionContext, inject } from '@angular/core';
+import { ReduxProvider } from './provider';
+import type { Store, Action } from 'redux';
 
 /**
  * Represents a type that extracts the action type from a given Redux store.
@@ -10,7 +10,7 @@ import type { Store, Action } from 'redux'
  * @internal
  */
 export type ExtractStoreActionType<StoreType extends Store> =
-  StoreType extends Store<any, infer ActionType> ? ActionType : never
+  StoreType extends Store<any, infer ActionType> ? ActionType : never;
 
 /**
  * Represents a custom injection that provides access to the Redux store.
@@ -25,7 +25,7 @@ export interface InjectStore<StoreType extends Store> {
    *
    * @returns The Redux store instance.
    */
-  (): StoreType
+  (): StoreType;
 
   /**
    * Returns the Redux store instance with specific state and action types.
@@ -35,12 +35,12 @@ export interface InjectStore<StoreType extends Store> {
    * @template StateType - The specific type of the state used in the store.
    * @template ActionType - The specific type of the actions used in the store.
    */
-    <
-      StateType extends ReturnType<StoreType['getState']> = ReturnType<
-        StoreType['getState']
-      >,
-      ActionType extends Action = ExtractStoreActionType<Store>,
-    >(): Store<StateType, ActionType>
+  <
+    StateType extends ReturnType<StoreType['getState']> = ReturnType<
+      StoreType['getState']
+    >,
+    ActionType extends Action = ExtractStoreActionType<Store>,
+  >(): Store<StateType, ActionType>;
 
   /**
    * Creates a "pre-typed" version of {@linkcode injectStore injectStore}
@@ -60,7 +60,7 @@ export interface InjectStore<StoreType extends Store> {
    */
   withTypes: <
     OverrideStoreType extends StoreType,
-  >() => InjectStore<OverrideStoreType>
+  >() => InjectStore<OverrideStoreType>;
 }
 
 /**
@@ -73,17 +73,17 @@ export function createStoreInjection<
   ActionType extends Action = Action,
 >() {
   const injectStore = () => {
-    assertInInjectionContext(injectStore)
-    const context = inject(ReduxProvider)
-    const { store } = context
-    return store
-  }
+    assertInInjectionContext(injectStore);
+    const context = inject(ReduxProvider);
+    const { store } = context;
+    return store;
+  };
 
   Object.assign(injectStore, {
     withTypes: () => injectStore,
-  })
+  });
 
-  return injectStore as InjectStore<Store<StateType, ActionType>>
+  return injectStore as InjectStore<Store<StateType, ActionType>>;
 }
 
 /**
@@ -103,4 +103,4 @@ export function createStoreInjection<
  *   store = injectStore()
  * }
  */
-export const injectStore = /* #__PURE__*/ createStoreInjection()
+export const injectStore = /* #__PURE__*/ createStoreInjection();
diff --git a/projects/angular-redux/src/lib/provide-redux.ts b/projects/angular-redux/src/lib/provide-redux.ts
index d4c3ce7..2c0b8b3 100644
--- a/projects/angular-redux/src/lib/provide-redux.ts
+++ b/projects/angular-redux/src/lib/provide-redux.ts
@@ -1,5 +1,5 @@
-import type { Action, Store, UnknownAction } from 'redux'
-import { createReduxProvider, ReduxProvider } from './provider'
+import type { Action, Store, UnknownAction } from 'redux';
+import { createReduxProvider, ReduxProvider } from './provider';
 
 export interface ProviderProps<
   A extends Action<string> = UnknownAction,
@@ -8,14 +8,15 @@ export interface ProviderProps<
   /**
    * The single Redux store in your application.
    */
-  store: Store<S, A>
+  store: Store<S, A>;
 }
 
-export function provideRedux<A extends Action<string> = UnknownAction, S = unknown>({
-  store
-}: ProviderProps<A, S>) {
+export function provideRedux<
+  A extends Action<string> = UnknownAction,
+  S = unknown,
+>({ store }: ProviderProps<A, S>) {
   return {
     provide: ReduxProvider,
-    useValue: createReduxProvider(store)
-  }
+    useValue: createReduxProvider(store),
+  };
 }
diff --git a/projects/angular-redux/src/lib/provider.ts b/projects/angular-redux/src/lib/provider.ts
index a1a14bf..482b5d6 100644
--- a/projects/angular-redux/src/lib/provider.ts
+++ b/projects/angular-redux/src/lib/provider.ts
@@ -1,26 +1,33 @@
-import { Injectable, OnDestroy } from '@angular/core'
-import type { Action, Store, UnknownAction } from 'redux'
-import { createSubscription } from './utils/Subscription'
+import { Injectable, OnDestroy } from '@angular/core';
+import type { Action, Store, UnknownAction } from 'redux';
+import { createSubscription } from './utils/Subscription';
 
-@Injectable({providedIn: null})
-export class ReduxProvider<A extends Action<string> = UnknownAction, S = unknown> implements OnDestroy {
+@Injectable({ providedIn: null })
+export class ReduxProvider<
+  A extends Action<string> = UnknownAction,
+  S = unknown,
+> implements OnDestroy
+{
   store!: Store<S, A>;
-  subscription!: ReturnType<typeof createSubscription>
+  subscription!: ReturnType<typeof createSubscription>;
 
   ngOnDestroy() {
-    this.subscription.tryUnsubscribe()
-    this.subscription.onStateChange = undefined
+    this.subscription.tryUnsubscribe();
+    this.subscription.onStateChange = undefined;
   }
 }
 
 // TODO: Ideally this runs in the constructor, but DI doesn't allow us to pass items to the constructor?
-export function createReduxProvider<A extends Action<string> = UnknownAction, S = unknown>(store: Store<S, A>) {
-  const provider = new ReduxProvider<A, S>()
-  provider.store = store
-  const subscription = createSubscription(store)
-  provider.subscription = subscription
-  subscription.onStateChange = subscription.notifyNestedSubs
-  subscription.trySubscribe()
+export function createReduxProvider<
+  A extends Action<string> = UnknownAction,
+  S = unknown,
+>(store: Store<S, A>) {
+  const provider = new ReduxProvider<A, S>();
+  provider.store = store;
+  const subscription = createSubscription(store);
+  provider.subscription = subscription;
+  subscription.onStateChange = subscription.notifyNestedSubs;
+  subscription.trySubscribe();
 
-  return provider
+  return provider;
 }
diff --git a/projects/angular-redux/src/lib/types.ts b/projects/angular-redux/src/lib/types.ts
index 1fd2f5e..eaedfd0 100644
--- a/projects/angular-redux/src/lib/types.ts
+++ b/projects/angular-redux/src/lib/types.ts
@@ -1 +1 @@
-export type EqualityFn<T> = (a: T, b: T) => boolean
+export type EqualityFn<T> = (a: T, b: T) => boolean;
diff --git a/projects/angular-redux/src/lib/utils/Subscription.ts b/projects/angular-redux/src/lib/utils/Subscription.ts
index 476c999..4d830a3 100644
--- a/projects/angular-redux/src/lib/utils/Subscription.ts
+++ b/projects/angular-redux/src/lib/utils/Subscription.ts
@@ -2,166 +2,166 @@
 // well as nesting subscriptions of descendant components, so that we can ensure the
 // ancestor components re-render before descendants
 
-type VoidFunc = () => void
+type VoidFunc = () => void;
 
 type Listener = {
-  callback: VoidFunc
-  next: Listener | null
-  prev: Listener | null
-}
+  callback: VoidFunc;
+  next: Listener | null;
+  prev: Listener | null;
+};
 
 function createListenerCollection() {
-  let first: Listener | null = null
-  let last: Listener | null = null
+  let first: Listener | null = null;
+  let last: Listener | null = null;
 
   return {
     clear() {
-      first = null
-      last = null
+      first = null;
+      last = null;
     },
 
     notify() {
-        let listener = first
-        while (listener) {
-          listener.callback()
-          listener = listener.next
-        }
+      let listener = first;
+      while (listener) {
+        listener.callback();
+        listener = listener.next;
+      }
     },
 
     get() {
-      const listeners: Listener[] = []
-      let listener = first
+      const listeners: Listener[] = [];
+      let listener = first;
       while (listener) {
-        listeners.push(listener)
-        listener = listener.next
+        listeners.push(listener);
+        listener = listener.next;
       }
-      return listeners
+      return listeners;
     },
 
     subscribe(callback: () => void) {
-      let isSubscribed = true
+      let isSubscribed = true;
 
       const listener: Listener = (last = {
         callback,
         next: null,
         prev: last,
-      })
+      });
 
       if (listener.prev) {
-        listener.prev.next = listener
+        listener.prev.next = listener;
       } else {
-        first = listener
+        first = listener;
       }
 
       return function unsubscribe() {
-        if (!isSubscribed || first === null) return
-        isSubscribed = false
+        if (!isSubscribed || first === null) return;
+        isSubscribed = false;
 
         if (listener.next) {
-          listener.next.prev = listener.prev
+          listener.next.prev = listener.prev;
         } else {
-          last = listener.prev
+          last = listener.prev;
         }
         if (listener.prev) {
-          listener.prev.next = listener.next
+          listener.prev.next = listener.next;
         } else {
-          first = listener.next
+          first = listener.next;
         }
-      }
+      };
     },
-  }
+  };
 }
 
-type ListenerCollection = ReturnType<typeof createListenerCollection>
+type ListenerCollection = ReturnType<typeof createListenerCollection>;
 
 export interface Subscription {
-  addNestedSub: (listener: VoidFunc) => VoidFunc
-  notifyNestedSubs: VoidFunc
-  handleChangeWrapper: VoidFunc
-  isSubscribed: () => boolean
-  onStateChange?: VoidFunc | null
-  trySubscribe: VoidFunc
-  tryUnsubscribe: VoidFunc
-  getListeners: () => ListenerCollection
+  addNestedSub: (listener: VoidFunc) => VoidFunc;
+  notifyNestedSubs: VoidFunc;
+  handleChangeWrapper: VoidFunc;
+  isSubscribed: () => boolean;
+  onStateChange?: VoidFunc | null;
+  trySubscribe: VoidFunc;
+  tryUnsubscribe: VoidFunc;
+  getListeners: () => ListenerCollection;
 }
 
 const nullListeners = {
   notify() {},
   get: () => [],
-} as unknown as ListenerCollection
+} as unknown as ListenerCollection;
 
 export function createSubscription(store: any, parentSub?: Subscription) {
-  let unsubscribe: VoidFunc | undefined
-  let listeners: ListenerCollection = nullListeners
+  let unsubscribe: VoidFunc | undefined;
+  let listeners: ListenerCollection = nullListeners;
 
   // Reasons to keep the subscription active
-  let subscriptionsAmount = 0
+  let subscriptionsAmount = 0;
 
   // Is this specific subscription subscribed (or only nested ones?)
-  let selfSubscribed = false
+  let selfSubscribed = false;
 
   function addNestedSub(listener: () => void) {
-    trySubscribe()
+    trySubscribe();
 
-    const cleanupListener = listeners.subscribe(listener)
+    const cleanupListener = listeners.subscribe(listener);
 
     // cleanup nested sub
-    let removed = false
+    let removed = false;
     return () => {
       if (!removed) {
-        removed = true
-        cleanupListener()
-        tryUnsubscribe()
+        removed = true;
+        cleanupListener();
+        tryUnsubscribe();
       }
-    }
+    };
   }
 
   function notifyNestedSubs() {
-    listeners.notify()
+    listeners.notify();
   }
 
   function handleChangeWrapper() {
     if (subscription.onStateChange) {
-      subscription.onStateChange()
+      subscription.onStateChange();
     }
   }
 
   function isSubscribed() {
-    return selfSubscribed
+    return selfSubscribed;
   }
 
   function trySubscribe() {
-    subscriptionsAmount++
+    subscriptionsAmount++;
     if (!unsubscribe) {
       unsubscribe = parentSub
         ? parentSub.addNestedSub(handleChangeWrapper)
-        : store.subscribe(handleChangeWrapper)
+        : store.subscribe(handleChangeWrapper);
 
-      listeners = createListenerCollection()
+      listeners = createListenerCollection();
     }
   }
 
   function tryUnsubscribe() {
-    subscriptionsAmount--
+    subscriptionsAmount--;
     if (unsubscribe && subscriptionsAmount === 0) {
-      unsubscribe()
-      unsubscribe = undefined
-      listeners.clear()
-      listeners = nullListeners
+      unsubscribe();
+      unsubscribe = undefined;
+      listeners.clear();
+      listeners = nullListeners;
     }
   }
 
   function trySubscribeSelf() {
     if (!selfSubscribed) {
-      selfSubscribed = true
-      trySubscribe()
+      selfSubscribed = true;
+      trySubscribe();
     }
   }
 
   function tryUnsubscribeSelf() {
     if (selfSubscribed) {
-      selfSubscribed = false
-      tryUnsubscribe()
+      selfSubscribed = false;
+      tryUnsubscribe();
     }
   }
 
@@ -173,7 +173,7 @@ export function createSubscription(store: any, parentSub?: Subscription) {
     trySubscribe: trySubscribeSelf,
     tryUnsubscribe: tryUnsubscribeSelf,
     getListeners: () => listeners,
-  }
+  };
 
-  return subscription
+  return subscription;
 }
diff --git a/projects/angular-redux/src/lib/utils/shallowEqual.ts b/projects/angular-redux/src/lib/utils/shallowEqual.ts
index a662707..f0b9f8f 100644
--- a/projects/angular-redux/src/lib/utils/shallowEqual.ts
+++ b/projects/angular-redux/src/lib/utils/shallowEqual.ts
@@ -1,13 +1,13 @@
 function is(x: unknown, y: unknown) {
   if (x === y) {
-    return x !== 0 || y !== 0 || 1 / x === 1 / y
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
   } else {
-    return x !== x && y !== y
+    return x !== x && y !== y;
   }
 }
 
 export function shallowEqual(objA: any, objB: any) {
-  if (is(objA, objB)) return true
+  if (is(objA, objB)) return true;
 
   if (
     typeof objA !== 'object' ||
@@ -15,22 +15,22 @@ export function shallowEqual(objA: any, objB: any) {
     typeof objB !== 'object' ||
     objB === null
   ) {
-    return false
+    return false;
   }
 
-  const keysA = Object.keys(objA)
-  const keysB = Object.keys(objB)
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
 
-  if (keysA.length !== keysB.length) return false
+  if (keysA.length !== keysB.length) return false;
 
   for (let i = 0; i < keysA.length; i++) {
     if (
       !Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
       !is(objA[keysA[i]], objB[keysA[i]])
     ) {
-      return false
+      return false;
     }
   }
 
-  return true
+  return true;
 }
diff --git a/projects/angular-redux/src/public-api.ts b/projects/angular-redux/src/public-api.ts
index ea18bbc..ed168a3 100644
--- a/projects/angular-redux/src/public-api.ts
+++ b/projects/angular-redux/src/public-api.ts
@@ -6,6 +6,6 @@ export * from './lib/inject-dispatch';
 export * from './lib/inject-selector';
 export * from './lib/inject-store';
 export * from './lib/provide-redux';
-export * from "./lib/provider"
-export * from "./lib/utils/shallowEqual"
-export type { Subscription } from './lib/utils/Subscription'
+export * from './lib/provider';
+export * from './lib/utils/shallowEqual';
+export type { Subscription } from './lib/utils/Subscription';
diff --git a/projects/angular-redux/src/tests/inject-dispatch.spec.ts b/projects/angular-redux/src/tests/inject-dispatch.spec.ts
index b38bbf8..61374a9 100644
--- a/projects/angular-redux/src/tests/inject-dispatch.spec.ts
+++ b/projects/angular-redux/src/tests/inject-dispatch.spec.ts
@@ -1,28 +1,26 @@
-import { createStore } from 'redux'
-import {
-  injectDispatch, provideRedux
-} from '../public-api'
-import {Component} from "@angular/core";
-import {render} from "@testing-library/angular";
+import { createStore } from 'redux';
+import { injectDispatch, provideRedux } from '../public-api';
+import { Component } from '@angular/core';
+import { render } from '@testing-library/angular';
 
-const store = createStore((c: number = 1): number => c + 1)
-const store2 = createStore((c: number = 1): number => c + 2)
+const store = createStore((c: number = 1): number => c + 1);
+const store2 = createStore((c: number = 1): number => c + 2);
 
 describe('injectDispatch', () => {
   it("returns the store's dispatch function", async () => {
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
-      template: "<p></p>"
+      template: '<p></p>',
     })
     class Testing {
       dispatch = injectDispatch();
     }
 
     const result = await render(Testing, {
-      providers: [provideRedux({store})]
-    })
+      providers: [provideRedux({ store })],
+    });
 
-    expect(result.fixture.componentRef.instance.dispatch).toBe(store.dispatch)
-  })
-})
+    expect(result.fixture.componentRef.instance.dispatch).toBe(store.dispatch);
+  });
+});
diff --git a/projects/angular-redux/src/tests/inject-selector-and-dispatch.spec.ts b/projects/angular-redux/src/tests/inject-selector-and-dispatch.spec.ts
index 1506d9b..61272ce 100644
--- a/projects/angular-redux/src/tests/inject-selector-and-dispatch.spec.ts
+++ b/projects/angular-redux/src/tests/inject-selector-and-dispatch.spec.ts
@@ -1,9 +1,9 @@
-import { Component } from '@angular/core'
-import { render } from '@testing-library/angular'
-import '@testing-library/jest-dom'
-import { configureStore, createSlice } from '@reduxjs/toolkit'
-import { provideRedux, injectDispatch, injectSelector } from '../public-api'
-import { userEvent } from '@testing-library/user-event'
+import { Component } from '@angular/core';
+import { render } from '@testing-library/angular';
+import '@testing-library/jest-dom';
+import { configureStore, createSlice } from '@reduxjs/toolkit';
+import { provideRedux, injectDispatch, injectSelector } from '../public-api';
+import { userEvent } from '@testing-library/user-event';
 
 const user = userEvent.setup();
 
@@ -14,10 +14,10 @@ const counterSlice = createSlice({
   },
   reducers: {
     increment: (state) => {
-      state.value += 1
-    }
+      state.value += 1;
+    },
   },
-})
+});
 
 @Component({
   selector: 'app-root',
@@ -25,21 +25,18 @@ const counterSlice = createSlice({
   template: `
     <div>
       <div>
-        <button
-          aria-label="Increment value"
-          (click)="dispatch(increment())"
-        >
+        <button aria-label="Increment value" (click)="dispatch(increment())">
           Increment
         </button>
         <span>Count: {{ count() }}</span>
       </div>
     </div>
-  `
+  `,
 })
 export class AppComponent {
-  count = injectSelector((state: any) => state.counter.value)
-  dispatch = injectDispatch()
-  increment = counterSlice.actions.increment
+  count = injectSelector((state: any) => state.counter.value);
+  dispatch = injectDispatch();
+  increment = counterSlice.actions.increment;
 }
 
 it('injectSelector should work without reactivity', async () => {
@@ -47,29 +44,29 @@ it('injectSelector should work without reactivity', async () => {
     reducer: {
       counter: counterSlice.reducer,
     },
-  })
+  });
 
-  const {getByText} = await render(AppComponent, {
-    providers: [provideRedux({store})]
-  })
+  const { getByText } = await render(AppComponent, {
+    providers: [provideRedux({ store })],
+  });
 
-  expect(getByText("Count: 0")).toBeInTheDocument();
-})
+  expect(getByText('Count: 0')).toBeInTheDocument();
+});
 
 it('injectSelector should work with reactivity', async () => {
   const store = configureStore({
     reducer: {
       counter: counterSlice.reducer,
     },
-  })
+  });
 
-  const {getByText, getByLabelText} = await render(AppComponent, {
-    providers: [provideRedux({store})]
-  })
+  const { getByText, getByLabelText } = await render(AppComponent, {
+    providers: [provideRedux({ store })],
+  });
 
-  expect(getByText("Count: 0")).toBeInTheDocument();
+  expect(getByText('Count: 0')).toBeInTheDocument();
 
-  await user.click(getByLabelText("Increment value"))
+  await user.click(getByLabelText('Increment value'));
 
-  expect(getByText("Count: 1")).toBeInTheDocument();
-})
+  expect(getByText('Count: 1')).toBeInTheDocument();
+});
diff --git a/projects/angular-redux/src/tests/inject-selector.spec.ts b/projects/angular-redux/src/tests/inject-selector.spec.ts
index 5a450d9..e6820c8 100644
--- a/projects/angular-redux/src/tests/inject-selector.spec.ts
+++ b/projects/angular-redux/src/tests/inject-selector.spec.ts
@@ -1,336 +1,327 @@
-import {InjectSelector, injectSelector, provideRedux, ReduxProvider, shallowEqual} from '../public-api'
-import {Component, effect, inject} from "@angular/core";
-import {render, waitFor} from "@testing-library/angular";
-import {AnyAction, createStore, Store} from "redux";
+import {
+  InjectSelector,
+  injectSelector,
+  provideRedux,
+  ReduxProvider,
+  shallowEqual,
+} from '../public-api';
+import { Component, effect, inject } from '@angular/core';
+import { render, waitFor } from '@testing-library/angular';
+import { AnyAction, createStore, Store } from 'redux';
 import '@testing-library/jest-dom';
-import {Subscription} from "../lib/utils/Subscription";
+import { Subscription } from '../lib/utils/Subscription';
 
 type NormalStateType = {
-  count: number
-}
-let normalStore: Store<NormalStateType, AnyAction>
-let renderedItems: any[] = []
-type RootState = ReturnType<typeof normalStore.getState>
-const injectNormalSelector: InjectSelector<RootState> = injectSelector
+  count: number;
+};
+let normalStore: Store<NormalStateType, AnyAction>;
+let renderedItems: any[] = [];
+type RootState = ReturnType<typeof normalStore.getState>;
+const injectNormalSelector: InjectSelector<RootState> = injectSelector;
 
 beforeEach(() => {
   normalStore = createStore(
-    ({count}: NormalStateType = {count: -1}): NormalStateType => ({
+    ({ count }: NormalStateType = { count: -1 }): NormalStateType => ({
       count: count + 1,
     }),
-  )
-  renderedItems = []
-})
+  );
+  renderedItems = [];
+});
 
 describe('injectSelector core subscription behavior', () => {
   it('selects the state on initial render', async () => {
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
-      template: "<div>Count: {{count()}}</div>"
+      template: '<div>Count: {{count()}}</div>',
     })
     class Testing {
-      count = injectNormalSelector((state) => state.count)
+      count = injectNormalSelector((state) => state.count);
     }
 
-    const {getByText} = await render(Testing, {
-      providers: [provideRedux({store: normalStore})]
-    })
+    const { getByText } = await render(Testing, {
+      providers: [provideRedux({ store: normalStore })],
+    });
 
-    expect(getByText("Count: 0")).toBeInTheDocument();
-  })
+    expect(getByText('Count: 0')).toBeInTheDocument();
+  });
 
   it('selects the state and renders the component when the store updates', async () => {
-    const selector = jest.fn((s: NormalStateType) => s.count)
+    const selector = jest.fn((s: NormalStateType) => s.count);
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
-      template: "<div>Count: {{count()}}</div>"
+      template: '<div>Count: {{count()}}</div>',
     })
     class Testing {
-      count = injectNormalSelector(selector)
+      count = injectNormalSelector(selector);
     }
 
-    const {findByText} = await render(Testing, {
-      providers: [provideRedux({store: normalStore})]
-    })
+    const { findByText } = await render(Testing, {
+      providers: [provideRedux({ store: normalStore })],
+    });
 
-    expect(await findByText("Count: 0")).toBeInTheDocument();
-    expect(selector).toHaveBeenCalledTimes(1)
+    expect(await findByText('Count: 0')).toBeInTheDocument();
+    expect(selector).toHaveBeenCalledTimes(1);
 
-    normalStore.dispatch({type: ''})
+    normalStore.dispatch({ type: '' });
 
-
-    expect(await findByText("Count: 1")).toBeInTheDocument();
-    expect(selector).toHaveBeenCalledTimes(2)
-  })
-})
+    expect(await findByText('Count: 1')).toBeInTheDocument();
+    expect(selector).toHaveBeenCalledTimes(2);
+  });
+});
 
 describe('injectSelector lifecycle interactions', () => {
   it('always uses the latest state', async () => {
-    const store = createStore((c: number = 1): number => c + 1, -1)
+    const store = createStore((c: number = 1): number => c + 1, -1);
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
-      template: "<div></div>"
+      template: '<div></div>',
     })
     class Testing {
-      selector = (c: number): number => c + 1
-      value = injectSelector(this.selector)
+      selector = (c: number): number => c + 1;
+      value = injectSelector(this.selector);
       _test = effect(() => {
-        renderedItems.push(this.value())
-      })
+        renderedItems.push(this.value());
+      });
     }
 
     await render(Testing, {
-      providers: [provideRedux({store})]
-    })
+      providers: [provideRedux({ store })],
+    });
 
-    expect(renderedItems).toEqual([1])
+    expect(renderedItems).toEqual([1]);
 
-    store.dispatch({type: ''})
+    store.dispatch({ type: '' });
 
-    await waitFor(() =>
-      expect(renderedItems).toEqual([1, 2])
-    )
-  })
+    await waitFor(() => expect(renderedItems).toEqual([1, 2]));
+  });
 
   it('subscribes to the store synchronously', async () => {
-    let appSubscription: Subscription | null = null
+    let appSubscription: Subscription | null = null;
 
     @Component({
-      selector: "child-root",
+      selector: 'child-root',
       standalone: true,
-      template: "<div>{{count()}}</div>"
+      template: '<div>{{count()}}</div>',
     })
     class Child {
-      count = injectNormalSelector((s) => s.count)
+      count = injectNormalSelector((s) => s.count);
     }
 
     function injectReduxAndAssignApp() {
       const contextVal = inject(ReduxProvider);
-      appSubscription = contextVal && contextVal.subscription
+      appSubscription = contextVal && contextVal.subscription;
       return contextVal;
     }
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
       imports: [Child],
       template: `
         @if (count() === 1) {
-          <child-root/>
+          <child-root />
         }
-      `
+      `,
     })
     class Parent {
       contextVal = injectReduxAndAssignApp();
-      count = injectNormalSelector((s) => s.count)
+      count = injectNormalSelector((s) => s.count);
     }
 
     await render(Parent, {
-      providers: [provideRedux({store: normalStore})]
-    })
+      providers: [provideRedux({ store: normalStore })],
+    });
 
     // Parent component only
-    expect(appSubscription!.getListeners().get().length).toBe(1)
+    expect(appSubscription!.getListeners().get().length).toBe(1);
 
-    normalStore.dispatch({type: ''})
+    normalStore.dispatch({ type: '' });
 
     // Parent component + 1 child component
     await waitFor(() =>
-      expect(appSubscription!.getListeners().get().length).toBe(2)
-    )
-  })
+      expect(appSubscription!.getListeners().get().length).toBe(2),
+    );
+  });
 
   it('unsubscribes when the component is unmounted', async () => {
-    let appSubscription: Subscription | null = null
+    let appSubscription: Subscription | null = null;
 
     @Component({
-      selector: "child-root",
+      selector: 'child-root',
       standalone: true,
-      template: "<div>{{count()}}</div>"
+      template: '<div>{{count()}}</div>',
     })
     class Child {
-      count = injectNormalSelector((s) => s.count)
+      count = injectNormalSelector((s) => s.count);
     }
 
     function injectReduxAndAssignApp() {
       const contextVal = inject(ReduxProvider);
-      appSubscription = contextVal && contextVal.subscription
+      appSubscription = contextVal && contextVal.subscription;
       return contextVal;
     }
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
       imports: [Child],
       template: `
         @if (count() === 0) {
-          <child-root/>
+          <child-root />
         }
-      `
+      `,
     })
     class Parent {
       contextVal = injectReduxAndAssignApp();
-      count = injectNormalSelector((s) => s.count)
+      count = injectNormalSelector((s) => s.count);
     }
 
     await render(Parent, {
-      providers: [provideRedux({store: normalStore})]
-    })
+      providers: [provideRedux({ store: normalStore })],
+    });
 
     // Parent component only
-    expect(appSubscription!.getListeners().get().length).toBe(2)
+    expect(appSubscription!.getListeners().get().length).toBe(2);
 
-    normalStore.dispatch({type: ''})
+    normalStore.dispatch({ type: '' });
 
     // Parent component + 1 child component
     await waitFor(() =>
-      expect(appSubscription!.getListeners().get().length).toBe(1)
-    )
-  })
+      expect(appSubscription!.getListeners().get().length).toBe(1),
+    );
+  });
 });
 
 describe('performance optimizations and bail-outs', () => {
   it('defaults to ref-equality to prevent unnecessary updates', async () => {
-    const state = {}
-    const store = createStore(() => state)
+    const state = {};
+    const store = createStore(() => state);
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
-      template: "<div></div>"
+      template: '<div></div>',
     })
     class Comp {
-      value = injectSelector((s) => s)
+      value = injectSelector((s) => s);
       _test = effect(() => {
-        renderedItems.push(this.value())
-      })
+        renderedItems.push(this.value());
+      });
     }
 
     await render(Comp, {
-      providers: [provideRedux({store})]
-    })
-
+      providers: [provideRedux({ store })],
+    });
 
-    expect(renderedItems.length).toBe(1)
+    expect(renderedItems.length).toBe(1);
 
-    store.dispatch({type: ''})
+    store.dispatch({ type: '' });
 
-    await waitFor(() =>
-      expect(renderedItems.length).toBe(1)
-    )
-  })
+    await waitFor(() => expect(renderedItems.length).toBe(1));
+  });
 
   it('allows other equality functions to prevent unnecessary updates', async () => {
     interface StateType {
-      count: number
-      stable: {}
+      count: number;
+      stable: {};
     }
 
     const store = createStore(
-      ({count, stable}: StateType = {count: -1, stable: {}}) => ({
+      ({ count, stable }: StateType = { count: -1, stable: {} }) => ({
         count: count + 1,
         stable,
       }),
-    )
+    );
 
     @Component({
-      selector: "app-comp",
+      selector: 'app-comp',
       standalone: true,
-      template: "<div></div>"
+      template: '<div></div>',
     })
     class Comp {
-      value = injectSelector(
-        (s: StateType) => Object.keys(s),
-        shallowEqual,
-      )
+      value = injectSelector((s: StateType) => Object.keys(s), shallowEqual);
       _test = effect(() => {
-        renderedItems.push(this.value())
-      })
+        renderedItems.push(this.value());
+      });
     }
 
     @Component({
-      selector: "app-other",
+      selector: 'app-other',
       standalone: true,
-      template: "<div></div>"
+      template: '<div></div>',
     })
     class Comp2 {
       value = injectSelector((s: StateType) => Object.keys(s), {
         equalityFn: shallowEqual,
-      })
+      });
       _test = effect(() => {
-        renderedItems.push(this.value())
-      })
+        renderedItems.push(this.value());
+      });
     }
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
       imports: [Comp, Comp2],
       template: `
-        <app-comp/>
-        <app-other/>
-      `
+        <app-comp />
+        <app-other />
+      `,
     })
-    class App {
-    }
+    class App {}
 
     await render(App, {
-      providers: [provideRedux({store})]
-    })
+      providers: [provideRedux({ store })],
+    });
 
-    expect(renderedItems.length).toBe(2)
+    expect(renderedItems.length).toBe(2);
 
-    store.dispatch({type: ''})
+    store.dispatch({ type: '' });
 
-    await waitFor(() =>
-      expect(renderedItems.length).toBe(2)
-    )
+    await waitFor(() => expect(renderedItems.length).toBe(2));
   });
 
   it('calls selector exactly once on mount and on update', async () => {
     interface StateType {
-      count: number
+      count: number;
     }
 
-    const store = createStore(({count}: StateType = {count: 0}) => ({
+    const store = createStore(({ count }: StateType = { count: 0 }) => ({
       count: count + 1,
-    }))
+    }));
 
     const selector = jest.fn((s: StateType) => {
-      return s.count
-    })
-    const renderedItems: number[] = []
-
+      return s.count;
+    });
+    const renderedItems: number[] = [];
 
     @Component({
-      selector: "app-root",
+      selector: 'app-root',
       standalone: true,
-      template: "<div></div>"
+      template: '<div></div>',
     })
     class Comp {
-      value = injectSelector(selector)
+      value = injectSelector(selector);
       _test = effect(() => {
-        renderedItems.push(this.value())
-      })
+        renderedItems.push(this.value());
+      });
     }
 
     await render(Comp, {
-      providers: [provideRedux({store})]
-    })
+      providers: [provideRedux({ store })],
+    });
 
-    expect(selector).toHaveBeenCalledTimes(1)
-    expect(renderedItems.length).toEqual(1)
+    expect(selector).toHaveBeenCalledTimes(1);
+    expect(renderedItems.length).toEqual(1);
 
-    store.dispatch({type: ''})
+    store.dispatch({ type: '' });
 
-    await waitFor(() =>
-      expect(selector).toHaveBeenCalledTimes(2)
-    )
-    expect(renderedItems.length).toEqual(2)
+    await waitFor(() => expect(selector).toHaveBeenCalledTimes(2));
+    expect(renderedItems.length).toEqual(2);
   });
 });
diff --git a/projects/angular-redux/src/tests/injections.withTypes.spec.ts b/projects/angular-redux/src/tests/injections.withTypes.spec.ts
index 83fefe0..35375e9 100644
--- a/projects/angular-redux/src/tests/injections.withTypes.spec.ts
+++ b/projects/angular-redux/src/tests/injections.withTypes.spec.ts
@@ -1,76 +1,80 @@
-import type { Action, ThunkAction } from '@reduxjs/toolkit'
-import { configureStore, createAsyncThunk, createSlice } from '@reduxjs/toolkit'
-import { injectDispatch, injectSelector, injectStore } from "../public-api"
+import type { Action, ThunkAction } from '@reduxjs/toolkit';
+import {
+  configureStore,
+  createAsyncThunk,
+  createSlice,
+} from '@reduxjs/toolkit';
+import { injectDispatch, injectSelector, injectStore } from '../public-api';
 
 export interface CounterState {
-  counter: number
+  counter: number;
 }
 
 const initialState: CounterState = {
   counter: 0,
-}
+};
 
 export const counterSlice = createSlice({
   name: 'counter',
   initialState,
   reducers: {
     increment(state) {
-      state.counter++
+      state.counter++;
     },
   },
-})
+});
 
 export function fetchCount(amount = 1) {
   return new Promise<{ data: number }>((resolve) =>
     setTimeout(() => resolve({ data: amount }), 500),
-  )
+  );
 }
 
 export const incrementAsync = createAsyncThunk(
   'counter/fetchCount',
   async (amount: number) => {
-    const response = await fetchCount(amount)
+    const response = await fetchCount(amount);
     // The value we return becomes the `fulfilled` action payload
-    return response.data
+    return response.data;
   },
-)
+);
 
-const { increment } = counterSlice.actions
+const { increment } = counterSlice.actions;
 
 const counterStore = configureStore({
   reducer: counterSlice.reducer,
-})
+});
 
-type AppStore = typeof counterStore
-type AppDispatch = typeof counterStore.dispatch
-type RootState = ReturnType<typeof counterStore.getState>
+type AppStore = typeof counterStore;
+type AppDispatch = typeof counterStore.dispatch;
+type RootState = ReturnType<typeof counterStore.getState>;
 type AppThunk<ThunkReturnType = void> = ThunkAction<
   ThunkReturnType,
   RootState,
   unknown,
   Action
->
+>;
 
 describe('injectSelector.withTypes<RootState>()', () => {
   test('should return injectSelector', () => {
-    const injectAppSelector = injectSelector.withTypes<RootState>()
+    const injectAppSelector = injectSelector.withTypes<RootState>();
 
-    expect(injectAppSelector).toBe(injectSelector)
-  })
-})
+    expect(injectAppSelector).toBe(injectSelector);
+  });
+});
 
 describe('injectDispatch.withTypes<AppDispatch>()', () => {
   test('should return injectDispatch', () => {
-    const injectAppDispatch = injectDispatch.withTypes<AppDispatch>()
+    const injectAppDispatch = injectDispatch.withTypes<AppDispatch>();
 
-    expect(injectAppDispatch).toBe(injectDispatch)
-  })
-})
+    expect(injectAppDispatch).toBe(injectDispatch);
+  });
+});
 
 describe('injectStore.withTypes<AppStore>()', () => {
   test('should return injectStore', () => {
-    const injectAppStore = injectStore.withTypes<AppStore>()
+    const injectAppStore = injectStore.withTypes<AppStore>();
 
-    expect(injectAppStore).toBe(injectStore)
-  })
-})
+    expect(injectAppStore).toBe(injectStore);
+  });
+});
diff --git a/projects/angular-redux/src/tests/utils/Subscription.spec.ts b/projects/angular-redux/src/tests/utils/Subscription.spec.ts
index 07a51f8..1743778 100644
--- a/projects/angular-redux/src/tests/utils/Subscription.spec.ts
+++ b/projects/angular-redux/src/tests/utils/Subscription.spec.ts
@@ -1,58 +1,58 @@
-import {  createSubscription, Subscription } from '../../lib/utils/Subscription'
-import { Store } from 'redux'
+import { createSubscription, Subscription } from '../../lib/utils/Subscription';
+import { Store } from 'redux';
 
 describe('Subscription', () => {
-  let notifications: string[]
-  let store: Store
-  let parent: Subscription
+  let notifications: string[];
+  let store: Store;
+  let parent: Subscription;
 
   beforeEach(() => {
-    notifications = []
-    store = { subscribe: () => jest.fn() } as unknown as Store
+    notifications = [];
+    store = { subscribe: () => jest.fn() } as unknown as Store;
 
-    parent = createSubscription(store)
-    parent.onStateChange = () => {}
-    parent.trySubscribe()
-  })
+    parent = createSubscription(store);
+    parent.onStateChange = () => {};
+    parent.trySubscribe();
+  });
 
   function subscribeChild(name: string) {
-    const child = createSubscription(store, parent)
-    child.onStateChange = () => notifications.push(name)
-    child.trySubscribe()
-    return child
+    const child = createSubscription(store, parent);
+    child.onStateChange = () => notifications.push(name);
+    child.trySubscribe();
+    return child;
   }
 
   it('listeners are notified in order', () => {
-    subscribeChild('child1')
-    subscribeChild('child2')
-    subscribeChild('child3')
-    subscribeChild('child4')
+    subscribeChild('child1');
+    subscribeChild('child2');
+    subscribeChild('child3');
+    subscribeChild('child4');
 
-    parent.notifyNestedSubs()
+    parent.notifyNestedSubs();
 
-    expect(notifications).toEqual(['child1', 'child2', 'child3', 'child4'])
-  })
+    expect(notifications).toEqual(['child1', 'child2', 'child3', 'child4']);
+  });
 
   it('listeners can be unsubscribed', () => {
-    const child1 = subscribeChild('child1')
-    const child2 = subscribeChild('child2')
-    const child3 = subscribeChild('child3')
+    const child1 = subscribeChild('child1');
+    const child2 = subscribeChild('child2');
+    const child3 = subscribeChild('child3');
 
-    child2.tryUnsubscribe()
-    parent.notifyNestedSubs()
+    child2.tryUnsubscribe();
+    parent.notifyNestedSubs();
 
-    expect(notifications).toEqual(['child1', 'child3'])
-    notifications.length = 0
+    expect(notifications).toEqual(['child1', 'child3']);
+    notifications.length = 0;
 
-    child1.tryUnsubscribe()
-    parent.notifyNestedSubs()
+    child1.tryUnsubscribe();
+    parent.notifyNestedSubs();
 
-    expect(notifications).toEqual(['child3'])
-    notifications.length = 0
+    expect(notifications).toEqual(['child3']);
+    notifications.length = 0;
 
-    child3.tryUnsubscribe()
-    parent.notifyNestedSubs()
+    child3.tryUnsubscribe();
+    parent.notifyNestedSubs();
 
-    expect(notifications).toEqual([])
-  })
-})
+    expect(notifications).toEqual([]);
+  });
+});
diff --git a/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts b/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts
index 3dbdb79..8e144c8 100644
--- a/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts
+++ b/projects/angular-redux/src/tests/utils/shallowEqual.spec.ts
@@ -1,4 +1,4 @@
-import { shallowEqual } from '../../public-api'
+import { shallowEqual } from '../../public-api';
 
 describe('Utils', () => {
   describe('shallowEqual', () => {
@@ -8,24 +8,24 @@ describe('Utils', () => {
           { a: 1, b: 2, c: undefined },
           { a: 1, b: 2, c: undefined },
         ),
-      ).toBe(true)
+      ).toBe(true);
 
       expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).toBe(
         true,
-      )
+      );
 
-      const o = {}
+      const o = {};
       expect(shallowEqual({ a: 1, b: 2, c: o }, { a: 1, b: 2, c: o })).toBe(
         true,
-      )
+      );
 
       const d = function () {
-        return 1
-      }
+        return 1;
+      };
       expect(
         shallowEqual({ a: 1, b: 2, c: o, d }, { a: 1, b: 2, c: o, d }),
-      ).toBe(true)
-    })
+      ).toBe(true);
+    });
 
     it('should return false if arguments fields are different function identities', () => {
       expect(
@@ -34,27 +34,27 @@ describe('Utils', () => {
             a: 1,
             b: 2,
             d: function () {
-              return 1
+              return 1;
             },
           },
           {
             a: 1,
             b: 2,
             d: function () {
-              return 1
+              return 1;
             },
           },
         ),
-      ).toBe(false)
-    })
+      ).toBe(false);
+    });
 
     it('should return false if first argument has too many keys', () => {
-      expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false)
-    })
+      expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false);
+    });
 
     it('should return false if second argument has too many keys', () => {
-      expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBe(false)
-    })
+      expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBe(false);
+    });
 
     it('should return false if arguments have different keys', () => {
       expect(
@@ -62,22 +62,22 @@ describe('Utils', () => {
           { a: 1, b: 2, c: undefined },
           { a: 1, bb: 2, c: undefined },
         ),
-      ).toBe(false)
-    })
+      ).toBe(false);
+    });
 
     it('should compare two NaN values', () => {
-      expect(shallowEqual(NaN, NaN)).toBe(true)
-    })
+      expect(shallowEqual(NaN, NaN)).toBe(true);
+    });
 
     it('should compare empty objects, with false', () => {
-      expect(shallowEqual({}, false)).toBe(false)
-      expect(shallowEqual(false, {})).toBe(false)
-      expect(shallowEqual([], false)).toBe(false)
-      expect(shallowEqual(false, [])).toBe(false)
-    })
+      expect(shallowEqual({}, false)).toBe(false);
+      expect(shallowEqual(false, {})).toBe(false);
+      expect(shallowEqual([], false)).toBe(false);
+      expect(shallowEqual(false, [])).toBe(false);
+    });
 
     it('should compare two zero values', () => {
-      expect(shallowEqual(0, 0)).toBe(true)
-    })
-  })
-})
+      expect(shallowEqual(0, 0)).toBe(true);
+    });
+  });
+});
diff --git a/projects/angular-redux/tsconfig.lib.json b/projects/angular-redux/tsconfig.lib.json
index 2359bf6..5aa5e9d 100644
--- a/projects/angular-redux/tsconfig.lib.json
+++ b/projects/angular-redux/tsconfig.lib.json
@@ -9,7 +9,5 @@
     "inlineSources": true,
     "types": []
   },
-  "exclude": [
-    "**/*.spec.ts"
-  ]
+  "exclude": ["**/*.spec.ts"]
 }
diff --git a/projects/angular-redux/tsconfig.schematics.json b/projects/angular-redux/tsconfig.schematics.json
index 65c5169..d6e4748 100644
--- a/projects/angular-redux/tsconfig.schematics.json
+++ b/projects/angular-redux/tsconfig.schematics.json
@@ -13,7 +13,11 @@
     "skipLibCheck": true,
     "strict": true
   },
-  "include": ["migrations/**/*.ts", "schematics/**/*.ts", "schematics-core/**/*.ts"],
+  "include": [
+    "migrations/**/*.ts",
+    "schematics/**/*.ts",
+    "schematics-core/**/*.ts"
+  ],
   "exclude": ["**/*.spec.ts"],
   "angularCompilerOptions": {
     "skipMetadataEmit": true,
diff --git a/projects/angular-redux/tsconfig.spec.json b/projects/angular-redux/tsconfig.spec.json
index d120faa..c5990e1 100644
--- a/projects/angular-redux/tsconfig.spec.json
+++ b/projects/angular-redux/tsconfig.spec.json
@@ -5,16 +5,8 @@
   "compilerOptions": {
     "outDir": "../../out-tsc/spec",
     "emitDecoratorMetadata": true,
-    "types": [
-      "jest"
-    ]
+    "types": ["jest"]
   },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.d.ts"
-  ],
-  "exclude": [
-    "./schematics/**/*.ts",
-    "./schematics-core/**/*.ts"
-  ]
+  "include": ["**/*.spec.ts", "**/*.d.ts"],
+  "exclude": ["./schematics/**/*.ts", "./schematics-core/**/*.ts"]
 }
diff --git a/tsconfig.json b/tsconfig.json
index b28cc5b..f7b2a8b 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,9 +4,7 @@
   "compileOnSave": false,
   "compilerOptions": {
     "paths": {
-      "angular-redux": [
-        "./dist/angular-redux"
-      ]
+      "angular-redux": ["./dist/angular-redux"]
     },
     "outDir": "./dist/out-tsc",
     "strict": true,
@@ -24,10 +22,7 @@
     "importHelpers": true,
     "target": "ES2022",
     "module": "ES2022",
-    "lib": [
-      "ES2022",
-      "dom"
-    ],
+    "lib": ["ES2022", "dom"],
     "types": ["jest"]
   },
   "angularCompilerOptions": {
diff --git a/website/docusaurus.config.js b/website/docusaurus.config.js
index 123302e..154ee5f 100644
--- a/website/docusaurus.config.js
+++ b/website/docusaurus.config.js
@@ -11,128 +11,125 @@
 const siteConfig = {
   presets: [
     [
-      '@docusaurus/preset-classic',
+      "@docusaurus/preset-classic",
       {
         docs: {
-          path: '../docs',
-          routeBasePath: '/',
-          sidebarPath: require.resolve('./sidebars.js'),
+          path: "../docs",
+          routeBasePath: "/",
+          sidebarPath: require.resolve("./sidebars.js"),
           showLastUpdateTime: true,
-          editUrl: 'https://github.com/reduxjs/angular-redux/edit/main/website',
-          include: [
-            '{introduction,tutorials}/*.{md,mdx}'
-          ], // no other way to exclude node_modules
+          editUrl: "https://github.com/reduxjs/angular-redux/edit/main/website",
+          include: ["{introduction,tutorials}/*.{md,mdx}"], // no other way to exclude node_modules
         },
         theme: {
           customCss: [
-            require.resolve('./static/css/custom.css'),
-            require.resolve('./static/css/404.css'),
-            require.resolve('./static/css/codeblock.css'),
+            require.resolve("./static/css/custom.css"),
+            require.resolve("./static/css/404.css"),
+            require.resolve("./static/css/codeblock.css"),
           ],
         },
       },
     ],
   ],
-  title: 'Angular Redux', // Title for your website.
-  onBrokenLinks: 'throw',
-  tagline: 'Official Angular bindings for Redux',
-  url: 'https://angular-redux.js.org', // Your website URL
-  baseUrl: '/',
+  title: "Angular Redux", // Title for your website.
+  onBrokenLinks: "throw",
+  tagline: "Official Angular bindings for Redux",
+  url: "https://angular-redux.js.org", // Your website URL
+  baseUrl: "/",
   // Used for publishing and more
-  projectName: 'angular-redux',
-  organizationName: 'reduxjs',
+  projectName: "angular-redux",
+  organizationName: "reduxjs",
 
   // For no header links in the top nav bar -> headerLinks: [],
   /* path to images for header/footer */
-  favicon: 'img/favicon/favicon.ico',
+  favicon: "img/favicon/favicon.ico",
 
   // Add custom scripts here that would be placed in <script> tags.
   scripts: [
-    '/scripts/sidebarScroll.js',
-    '/scripts/codeblock.js',
+    "/scripts/sidebarScroll.js",
+    "/scripts/codeblock.js",
     {
-      src: 'https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.0/clipboard.min.js',
+      src: "https://cdnjs.cloudflare.com/ajax/libs/clipboard.js/2.0.0/clipboard.min.js",
       async: true,
     },
   ],
   // You may provide arbitrary config keys to be used as needed by your
   // template. For example, if you need your repo's URL...
   customFields: {
-    repoUrl: 'https://github.com/reduxjs/angular-redux',
+    repoUrl: "https://github.com/reduxjs/angular-redux",
   },
   themeConfig: {
-    metadata: [{ name: 'twitter:card', content: 'summary' }],
+    metadata: [{ name: "twitter:card", content: "summary" }],
     prism: {
-      theme: require('./static/scripts/monokaiTheme.js'),
+      theme: require("./static/scripts/monokaiTheme.js"),
     },
-    image: 'img/redux-logo-landscape.png',
+    image: "img/redux-logo-landscape.png",
     navbar: {
-      title: 'Angular Redux',
+      title: "Angular Redux",
       logo: {
-        alt: 'Redux Logo',
-        src: 'img/redux.svg',
+        alt: "Redux Logo",
+        src: "img/redux.svg",
       },
       items: [
         {
-          to: 'introduction/getting-started',
-          label: 'Getting Started',
-          position: 'right',
+          to: "introduction/getting-started",
+          label: "Getting Started",
+          position: "right",
         },
         {
-          to: 'tutorials/quick-start',
-          label: 'Tutorial',
-          position: 'right',
+          to: "tutorials/quick-start",
+          label: "Tutorial",
+          position: "right",
         },
         {
-          href: 'https://www.github.com/reduxjs/angular-redux',
-          label: 'GitHub',
-          position: 'right',
-          className: 'github',
+          href: "https://www.github.com/reduxjs/angular-redux",
+          label: "GitHub",
+          position: "right",
+          className: "github",
         },
         {
-          href: '/introduction/getting-started#help-and-discussion',
-          label: 'Need help?',
-          position: 'right',
+          href: "/introduction/getting-started#help-and-discussion",
+          label: "Need help?",
+          position: "right",
         },
       ],
     },
     footer: {
-      style: 'dark',
+      style: "dark",
       logo: {
-        alt: 'Redux Logo',
-        src: 'img/redux_white.svg',
+        alt: "Redux Logo",
+        src: "img/redux_white.svg",
       },
-      copyright:
-        'Copyright (c) 2024-present the Redux documentation authors.',
+      copyright: "Copyright (c) 2024-present the Redux documentation authors.",
       links: [
         {
-          title: 'Docs',
+          title: "Docs",
           items: [
             {
-              label: 'Introduction',
-              to: 'introduction/getting-started',
+              label: "Introduction",
+              to: "introduction/getting-started",
             },
           ],
         },
         {
-          title: 'Community',
+          title: "Community",
           items: [
             {
-              label: 'Stack Overflow',
-              href: 'https://stackoverflow.com/questions/tagged/angular-redux',
+              label: "Stack Overflow",
+              href: "https://stackoverflow.com/questions/tagged/angular-redux",
             },
             {
-              label: 'Discord',
-              href: 'https://discord.gg/0ZcbPKXt5bZ6au5t',
+              label: "Discord",
+              href: "https://discord.gg/0ZcbPKXt5bZ6au5t",
             },
           ],
         },
         {
-          title: 'More',
+          title: "More",
           items: [
             {
-              label: 'GitHub',
-              href: 'https://github.com/reduxjs/angular-redux',
+              label: "GitHub",
+              href: "https://github.com/reduxjs/angular-redux",
             },
             {
               html: `
@@ -162,8 +159,8 @@ const siteConfig = {
           ],
         },
       ],
-    }
-  }
-}
+    },
+  },
+};
 
-module.exports = siteConfig
+module.exports = siteConfig;
diff --git a/website/sidebars.js b/website/sidebars.js
index b6be13f..fe40a71 100644
--- a/website/sidebars.js
+++ b/website/sidebars.js
@@ -1,21 +1,16 @@
 module.exports = {
   docs: [
     {
-      type: 'category',
-      label: 'Introduction',
+      type: "category",
+      label: "Introduction",
       collapsed: false,
-      items: [
-        'introduction/getting-started'
-      ],
+      items: ["introduction/getting-started"],
     },
     {
-      type: 'category',
-      label: 'Tutorials',
+      type: "category",
+      label: "Tutorials",
       collapsed: false,
-      items: [
-        'tutorials/quick-start',
-        'tutorials/typescript-quick-start'
-      ],
-    }
+      items: ["tutorials/quick-start", "tutorials/typescript-quick-start"],
+    },
   ],
-}
+};
diff --git a/website/src/pages/index.js b/website/src/pages/index.js
index 26cf33e..cf85ceb 100644
--- a/website/src/pages/index.js
+++ b/website/src/pages/index.js
@@ -1,16 +1,16 @@
-import React, { useEffect } from 'react'
-import classnames from 'classnames'
-import Layout from '@theme/Layout'
-import Link from '@docusaurus/Link'
-import useDocusaurusContext from '@docusaurus/useDocusaurusContext'
-import useBaseUrl from '@docusaurus/useBaseUrl'
-import styles from './styles.module.css'
+import React, { useEffect } from "react";
+import classnames from "classnames";
+import Layout from "@theme/Layout";
+import Link from "@docusaurus/Link";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+import useBaseUrl from "@docusaurus/useBaseUrl";
+import styles from "./styles.module.css";
 
 const features = [
   {
     content: (
       <p>
-        Angular Redux is maintained by the Redux team, and{' '}
+        Angular Redux is maintained by the Redux team, and{" "}
         <strong>
           kept up-to-date with the latest APIs from Redux and Angular
         </strong>
@@ -18,8 +18,8 @@ const features = [
       </p>
     ),
     image: <img src="img/noun_Certificate_1945625.svg" />,
-    imageAlign: 'top',
-    title: 'Official',
+    imageAlign: "top",
+    title: "Official",
   },
   {
     content: (
@@ -30,40 +30,40 @@ const features = [
       </p>
     ),
     image: <img src="img/noun_Check_1870817.svg" />,
-    imageAlign: 'top',
-    title: 'Predictable',
+    imageAlign: "top",
+    title: "Predictable",
   },
   {
     content: (
       <p>
-        Provides APIs that{' '}
+        Provides APIs that{" "}
         <strong>enable your components to interact with the Redux store</strong>
         , so you don't have to write that logic yourself.
       </p>
     ),
     image: <img src="img/noun_Box_1664404.svg" />,
-    imageAlign: 'top',
-    title: 'Encapsulated',
+    imageAlign: "top",
+    title: "Encapsulated",
   },
   {
     content: (
       <p>
-        Automatically implements{' '}
+        Automatically implements{" "}
         <strong>complex performance optimizations</strong>, so that your own
         component only re-renders when the data it needs has actually changed.
       </p>
     ),
     image: <img src="img/noun_Rocket_1245262.svg" />,
-    imageAlign: 'top',
-    title: 'Optimized',
+    imageAlign: "top",
+    title: "Optimized",
   },
-]
+];
 
 const otherLibraries = [
   {
-    content: 'A predictable state container for JavaScript applications',
-    title: 'Redux',
-    link: 'https://redux.js.org',
+    content: "A predictable state container for JavaScript applications",
+    title: "Redux",
+    link: "https://redux.js.org",
     image: (
       <svg
         xmlns="http://www.w3.org/2000/svg"
@@ -78,9 +78,9 @@ const otherLibraries = [
   },
   {
     content:
-      'The official, opinionated, batteries-included toolset for efficient Redux development',
-    title: 'Redux Toolkit',
-    link: 'https://redux-toolkit.js.org',
+      "The official, opinionated, batteries-included toolset for efficient Redux development",
+    title: "Redux Toolkit",
+    link: "https://redux-toolkit.js.org",
     image: (
       <svg
         xmlns="http://www.w3.org/2000/svg"
@@ -93,21 +93,21 @@ const otherLibraries = [
       </svg>
     ),
   },
-]
+];
 
 function Home() {
-  const context = useDocusaurusContext()
-  const { siteConfig = {} } = context
+  const context = useDocusaurusContext();
+  const { siteConfig = {} } = context;
   useEffect(() => {
-    const script = document.createElement('script')
-    script.src = 'https://buttons.github.io/buttons.js'
-    script.async = true
-    document.body.appendChild(script)
-  }, [])
+    const script = document.createElement("script");
+    script.src = "https://buttons.github.io/buttons.js";
+    script.async = true;
+    document.body.appendChild(script);
+  }, []);
 
   return (
     <Layout title={siteConfig.title} description={siteConfig.tagline}>
-      <header className={classnames('hero hero--primary', styles.heroBanner)}>
+      <header className={classnames("hero hero--primary", styles.heroBanner)}>
         <div className="container">
           <div className={styles.title}>
             <img
@@ -124,10 +124,10 @@ function Home() {
           <div className={styles.buttons}>
             <Link
               className={classnames(
-                'button button--secondary button--lg',
+                "button button--secondary button--lg",
                 styles.getStarted,
               )}
-              to={useBaseUrl('introduction/getting-started')}
+              to={useBaseUrl("introduction/getting-started")}
             >
               Get Started
             </Link>
@@ -137,10 +137,10 @@ function Home() {
       <main>
         {features && features.length && (
           <section className={styles.features}>
-            <div className={classnames('container', styles.featureBlock)}>
+            <div className={classnames("container", styles.featureBlock)}>
               <div className="row">
                 {features.map(({ image, title, content }, idx) => (
-                  <div key={idx} className={classnames('col', styles.feature)}>
+                  <div key={idx} className={classnames("col", styles.feature)}>
                     {image && (
                       <div className={`text--center ${styles.blockImage}`}>
                         {image}
@@ -170,7 +170,7 @@ function Home() {
                 {otherLibraries.map(({ image, title, content, link }, idx) => (
                   <div
                     key={idx}
-                    className={classnames('col col--6', styles.feature)}
+                    className={classnames("col col--6", styles.feature)}
                   >
                     <h2 className="text--center">
                       <a href={link} className={styles.featureAnchor}>
@@ -187,7 +187,7 @@ function Home() {
         )}
       </main>
     </Layout>
-  )
+  );
 }
 
-export default Home
+export default Home;
diff --git a/website/src/pages/styles.module.css b/website/src/pages/styles.module.css
index 7d8dd47..9ff6c6c 100644
--- a/website/src/pages/styles.module.css
+++ b/website/src/pages/styles.module.css
@@ -40,7 +40,7 @@
   max-width: 80px;
 }
 
-html[data-theme='dark'] .blockImage img {
+html[data-theme="dark"] .blockImage img {
   filter: invert(100%);
 }
 
diff --git a/website/src/theme/NotFound.js b/website/src/theme/NotFound.js
index a5e8e2f..0178818 100644
--- a/website/src/theme/NotFound.js
+++ b/website/src/theme/NotFound.js
@@ -4,19 +4,19 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import React, { useEffect } from 'react'
-import Layout from '@theme/Layout'
-import useDocusaurusContext from '@docusaurus/useDocusaurusContext'
+import React, { useEffect } from "react";
+import Layout from "@theme/Layout";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
 
 function NotFound() {
-  const context = useDocusaurusContext()
-  const { siteConfig = {} } = context
+  const context = useDocusaurusContext();
+  const { siteConfig = {} } = context;
   useEffect(() => {
-    const script = document.createElement('script')
-    script.src = 'https://buttons.github.io/buttons.js'
-    script.async = true
-    document.body.appendChild(script)
-  }, [])
+    const script = document.createElement("script");
+    script.src = "https://buttons.github.io/buttons.js";
+    script.async = true;
+    document.body.appendChild(script);
+  }, []);
 
   const getTrackingScript = () => {
     if (
@@ -24,7 +24,7 @@ function NotFound() {
       !siteConfig.themeConfig.googleAnalytics ||
       !siteConfig.themeConfig.googleAnalytics.gaTrackingId
     ) {
-      return null
+      return null;
     }
 
     return {
@@ -36,9 +36,9 @@ function NotFound() {
         eventAction: window.location.href,
         eventLabel: document.referrer
       });`,
-    }
-  }
-  const trackingScript = getTrackingScript()
+    };
+  };
+  const trackingScript = getTrackingScript();
 
   return (
     <Layout title="Page Not Found">
@@ -53,7 +53,7 @@ function NotFound() {
         </div>
       </div>
     </Layout>
-  )
+  );
 }
 
-export default NotFound
+export default NotFound;
diff --git a/website/static/css/custom.css b/website/static/css/custom.css
index 5c7f107..7461fc1 100644
--- a/website/static/css/custom.css
+++ b/website/static/css/custom.css
@@ -59,7 +59,7 @@
   }
 }
 
-:root[data-theme='dark'] {
+:root[data-theme="dark"] {
   --ifm-color-primary: #ba8fff;
   --ifm-color-primary-dark: #7431ca;
   --ifm-color-primary-darker: #6d1cac;
@@ -73,7 +73,7 @@
   --blockquote-text-color: black;
 }
 
-:root[data-theme='dark'] .hero.hero--primary {
+:root[data-theme="dark"] .hero.hero--primary {
   --ifm-hero-background-color: #593d88;
   --ifm-hero-text-color: #ffffff;
 }
@@ -94,7 +94,7 @@ blockquote {
   border-radius: var(--ifm-global-radius);
 }
 
-html[data-theme='dark'] blockquote code {
+html[data-theme="dark"] blockquote code {
   background-color: var(--ifm-color-emphasis-800);
 }
 
@@ -108,7 +108,7 @@ html[data-theme='dark'] blockquote code {
   padding-right: var(--ifm-pre-padding);
   border-left: 0.25em solid #1976d2;
 }
-div[class*='codeBlockTitle'] {
+div[class*="codeBlockTitle"] {
   padding: 0.15rem var(--ifm-pre-padding);
 }
 
@@ -136,7 +136,7 @@ a.contents__link.contents__link--active {
   --ifm-hero-text-color: #ffffff;
 }
 
-html[data-theme='dark'] blockquote {
+html[data-theme="dark"] blockquote {
   border-left-color: var(--ifm-color-primary);
 }
 
diff --git a/website/static/scripts/codeblock.js b/website/static/scripts/codeblock.js
index 1b1543c..2a0eb03 100644
--- a/website/static/scripts/codeblock.js
+++ b/website/static/scripts/codeblock.js
@@ -1,45 +1,45 @@
-window.addEventListener('load', function () {
+window.addEventListener("load", function () {
   function button(label, ariaLabel, icon, className) {
-    const btn = document.createElement('button')
-    btn.classList.add('btnIcon', className)
-    btn.setAttribute('type', 'button')
-    btn.setAttribute('aria-label', ariaLabel)
+    const btn = document.createElement("button");
+    btn.classList.add("btnIcon", className);
+    btn.setAttribute("type", "button");
+    btn.setAttribute("aria-label", ariaLabel);
     btn.innerHTML =
       '<div class="btnIcon__body">' +
       icon +
       '<strong class="btnIcon__label">' +
       label +
-      '</strong>' +
-      '</div>'
-    return btn
+      "</strong>" +
+      "</div>";
+    return btn;
   }
 
   function addButtons(codeBlockSelector, btn) {
     document.querySelectorAll(codeBlockSelector).forEach(function (code) {
-      code.parentNode.appendChild(btn.cloneNode(true))
-    })
+      code.parentNode.appendChild(btn.cloneNode(true));
+    });
   }
 
   const copyIcon =
-    '<svg width="12" height="12" viewBox="340 364 14 15" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M342 375.974h4v.998h-4v-.998zm5-5.987h-5v.998h5v-.998zm2 2.994v-1.995l-3 2.993 3 2.994v-1.996h5v-1.995h-5zm-4.5-.997H342v.998h2.5v-.997zm-2.5 2.993h2.5v-.998H342v.998zm9 .998h1v1.996c-.016.28-.11.514-.297.702-.187.187-.422.28-.703.296h-10c-.547 0-1-.452-1-.998v-10.976c0-.546.453-.998 1-.998h3c0-1.107.89-1.996 2-1.996 1.11 0 2 .89 2 1.996h3c.547 0 1 .452 1 .998v4.99h-1v-2.995h-10v8.98h10v-1.996zm-9-7.983h8c0-.544-.453-.996-1-.996h-1c-.547 0-1-.453-1-.998 0-.546-.453-.998-1-.998-.547 0-1 .452-1 .998 0 .545-.453.998-1 .998h-1c-.547 0-1 .452-1 .997z" fill-rule="evenodd"/></svg>'
+    '<svg width="12" height="12" viewBox="340 364 14 15" xmlns="http://www.w3.org/2000/svg"><path fill="currentColor" d="M342 375.974h4v.998h-4v-.998zm5-5.987h-5v.998h5v-.998zm2 2.994v-1.995l-3 2.993 3 2.994v-1.996h5v-1.995h-5zm-4.5-.997H342v.998h2.5v-.997zm-2.5 2.993h2.5v-.998H342v.998zm9 .998h1v1.996c-.016.28-.11.514-.297.702-.187.187-.422.28-.703.296h-10c-.547 0-1-.452-1-.998v-10.976c0-.546.453-.998 1-.998h3c0-1.107.89-1.996 2-1.996 1.11 0 2 .89 2 1.996h3c.547 0 1 .452 1 .998v4.99h-1v-2.995h-10v8.98h10v-1.996zm-9-7.983h8c0-.544-.453-.996-1-.996h-1c-.547 0-1-.453-1-.998 0-.546-.453-.998-1-.998-.547 0-1 .452-1 .998 0 .545-.453.998-1 .998h-1c-.547 0-1 .452-1 .997z" fill-rule="evenodd"/></svg>';
 
   addButtons(
-    '.hljs',
-    button('Copy', 'Copy code to clipboard', copyIcon, 'btnClipboard'),
-  )
+    ".hljs",
+    button("Copy", "Copy code to clipboard", copyIcon, "btnClipboard"),
+  );
 
-  const clipboard = new ClipboardJS('.btnClipboard', {
+  const clipboard = new ClipboardJS(".btnClipboard", {
     target: function (trigger) {
-      return trigger.parentNode.querySelector('code')
+      return trigger.parentNode.querySelector("code");
     },
-  })
+  });
 
-  clipboard.on('success', function (event) {
-    event.clearSelection()
-    const textEl = event.trigger.querySelector('.btnIcon__label')
-    textEl.textContent = 'Copied'
+  clipboard.on("success", function (event) {
+    event.clearSelection();
+    const textEl = event.trigger.querySelector(".btnIcon__label");
+    textEl.textContent = "Copied";
     setTimeout(function () {
-      textEl.textContent = 'Copy'
-    }, 2000)
-  })
-})
+      textEl.textContent = "Copy";
+    }, 2000);
+  });
+});
diff --git a/website/static/scripts/monokaiTheme.js b/website/static/scripts/monokaiTheme.js
index bd3eebd..28881ab 100644
--- a/website/static/scripts/monokaiTheme.js
+++ b/website/static/scripts/monokaiTheme.js
@@ -1,62 +1,62 @@
 module.exports = {
   plain: {
-    color: '#f8f8f2',
-    backgroundColor: '#272822',
+    color: "#f8f8f2",
+    backgroundColor: "#272822",
   },
   styles: [
     {
-      types: ['comment', 'prolog', 'doctype', 'cdata'],
+      types: ["comment", "prolog", "doctype", "cdata"],
       style: {
-        color: '#778090',
+        color: "#778090",
       },
     },
     {
-      types: ['punctuation'],
+      types: ["punctuation"],
       style: {
-        color: '#F8F8F2',
+        color: "#F8F8F2",
       },
     },
     {
-      types: ['property', 'tag', 'constant', 'symbol', 'deleted'],
+      types: ["property", "tag", "constant", "symbol", "deleted"],
       style: {
-        color: '#F92672',
+        color: "#F92672",
       },
     },
     {
-      types: ['boolean', 'number'],
+      types: ["boolean", "number"],
       style: {
-        color: '#AE81FF',
+        color: "#AE81FF",
       },
     },
     {
-      types: ['selector', 'attr-name', 'string', 'char', 'builtin', 'inserted'],
+      types: ["selector", "attr-name", "string", "char", "builtin", "inserted"],
       style: {
-        color: '#a6e22e',
+        color: "#a6e22e",
       },
     },
     {
-      types: ['operator', 'entity', 'url', 'variable'],
+      types: ["operator", "entity", "url", "variable"],
       style: {
-        color: '#F8F8F2',
+        color: "#F8F8F2",
       },
     },
     {
-      types: ['atrule', 'attr-value', 'function'],
+      types: ["atrule", "attr-value", "function"],
       style: {
-        color: '#E6D874',
+        color: "#E6D874",
       },
     },
     {
-      types: ['keyword'],
+      types: ["keyword"],
       style: {
-        color: '#F92672',
+        color: "#F92672",
       },
     },
     {
-      types: ['regex', 'important'],
+      types: ["regex", "important"],
       style: {
-        color: '#FD971F',
+        color: "#FD971F",
       },
     },
   ],
-}
+};
diff --git a/website/static/scripts/sidebarScroll.js b/website/static/scripts/sidebarScroll.js
index 8625f94..fdfd9f6 100644
--- a/website/static/scripts/sidebarScroll.js
+++ b/website/static/scripts/sidebarScroll.js
@@ -1,10 +1,10 @@
-document.addEventListener('DOMContentLoaded', () => {
+document.addEventListener("DOMContentLoaded", () => {
   // Find the active nav item in the sidebar
-  const item = document.getElementsByClassName('navListItemActive')[0]
+  const item = document.getElementsByClassName("navListItemActive")[0];
   if (!item) {
-    return
+    return;
   }
-  const bounding = item.getBoundingClientRect()
+  const bounding = item.getBoundingClientRect();
   if (
     bounding.top >= 0 &&
     bounding.bottom <=
@@ -13,7 +13,7 @@ document.addEventListener('DOMContentLoaded', () => {
     // Already visible.  Do nothing.
   } else {
     // Not visible.  Scroll sidebar.
-    item.scrollIntoView({ block: 'center', inline: 'nearest' })
-    document.body.scrollTop = document.documentElement.scrollTop = 0
+    item.scrollIntoView({ block: "center", inline: "nearest" });
+    document.body.scrollTop = document.documentElement.scrollTop = 0;
   }
-})
+});
diff --git a/yarn.lock b/yarn.lock
index 0e3bf70..1417576 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4566,6 +4566,7 @@ __metadata:
     jest: "npm:^29.7.0"
     jest-environment-jsdom: "npm:^29.7.0"
     ng-packagr: "npm:^18.2.0"
+    prettier: "npm:^3.3.3"
     redux: "npm:^5.0.1"
     rxjs: "npm:~7.8.0"
     ts-jest: "npm:^29.2.5"
@@ -16269,6 +16270,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"prettier@npm:^3.3.3":
+  version: 3.3.3
+  resolution: "prettier@npm:3.3.3"
+  bin:
+    prettier: bin/prettier.cjs
+  checksum: 10/5beac1f30b5b40162532b8e2f7c3a4eb650910a2695e9c8512a62ffdc09dae93190c29db9107fa7f26d1b6c71aad3628ecb9b5de1ecb0911191099be109434d7
+  languageName: node
+  linkType: hard
+
 "pretty-error@npm:^4.0.0":
   version: 4.0.0
   resolution: "pretty-error@npm:4.0.0"

From 33e626a2476bb1b41fe30dbe1ef0b8cd779c211d Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Sun, 15 Sep 2024 01:19:29 -0700
Subject: [PATCH 5/7] docs: add various docs files

---
 CHANGELOG.md                     |  1 +
 CODE_OF_CONDUCT.md               | 13 +++++++
 CONTRIBUTING.md                  | 65 ++++++++++++++++++++++++++++++++
 LICENSE.md                       | 21 +++++++++++
 netlify.toml                     | 22 +++++++++++
 projects/angular-redux/README.md | 39 ++++---------------
 6 files changed, 130 insertions(+), 31 deletions(-)
 create mode 100644 CHANGELOG.md
 create mode 100644 CODE_OF_CONDUCT.md
 create mode 100644 LICENSE.md
 create mode 100644 netlify.toml

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..1085a74
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1 @@
+All notable changes are described on the [Releases](https://github.com/reduxjs/react-redux/releases) page.
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..4ead0e1
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 05bce4c..6423282 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,5 +1,70 @@
+# Contributing
+
+We are open to, and grateful for, any contributions made by the community. By contributing to Angular Redux, you agree to abide by the [code of conduct](https://github.com/reduxjs/angular-redux/blob/master/CODE_OF_CONDUCT.md).
+
+Please review the [Redux Style Guide](https://redux.js.org/style-guide/style-guide) in the Redux docs to keep track of our best practices.
+
+## Reporting Issues and Asking Questions
+
+Before opening an issue, please search the [issue tracker](https://github.com/reduxjs/angular-redux/issues) to make sure your issue hasn't already been reported.
+
+Please ask any general and implementation specific questions on [Stack Overflow with a Redux tag](http://stackoverflow.com/questions/tagged/redux?sort=votes&pageSize=50) for support.
+
+## Development
+
+Visit the [Issue tracker](https://github.com/reduxjs/angular-redux/issues) to find a list of open issues that need attention.
+
+Fork, then clone the repo:
+
+```
+git clone https://github.com/your-username/angular-redux.git
+```
+
+This repository uses Yarn v4 to manage packages. You'll need to have Yarn v1.22 installed globally on your system first, as Yarn v4 depends on that being available first. Install dependencies with:
+
+```
+yarn install
+```
+
+### Building
+
+Running the `build` task will create an ESM build.
+
+```
+yarn build
+```
+
+### Testing and Linting
+
+To run the tests:
+
+```
+yarn test
+```
+
+### New Features
+
+Please open an issue with a proposal for a new feature or refactoring before starting on the work. We don't want you to waste your efforts on a pull request that we won't want to accept.
+
+## Submitting Changes
+
+- Open a new issue in the [Issue tracker](https://github.com/reduxjs/angular-redux/issues).
+- Fork the repo.
+- Create a new feature branch based off the `main` branch.
+- Make sure all tests pass and there are no linting errors.
+- Submit a pull request, referencing any issues it addresses.
+
+Please try to keep your pull request focused in scope and avoid including unrelated commits.
+
+After you have submitted your pull request, we'll try to get back to you as soon as possible. We may suggest some changes or improvements.
+
+Thank you for contributing!
+
+
 # Cutting a release
 
+If you are a maintainer and want to cut a release, follow these steps:
+
 - `yarn build`
 - `cd dist && angular-redux`
 - `npm publish`
diff --git a/LICENSE.md b/LICENSE.md
new file mode 100644
index 0000000..e6aa3b1
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024-present Corbin Crutchley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/netlify.toml b/netlify.toml
new file mode 100644
index 0000000..8bd6a7a
--- /dev/null
+++ b/netlify.toml
@@ -0,0 +1,22 @@
+[build]
+  base    = "website"
+  publish = "website/build"
+  command = "yarn && yarn build && cp _redirects ./build"
+  ignore  = "git diff --quiet HEAD^ HEAD -- ../docs/ .  ../netlify.toml"
+
+[build.environment]
+NODE_VERSION = "20"
+NODE_OPTIONS = "--max_old_space_size=4096"
+NETLIFY_USE_YARN = "true"
+YARN_VERSION = "1.22.10"
+
+
+[[plugins]]
+  package = "netlify-plugin-cache"
+  [plugins.inputs]
+    paths = [
+      "node_modules/.cache",
+      "website/node_modules/.cache",
+      ".yarn/.cache"
+    ]
+
diff --git a/projects/angular-redux/README.md b/projects/angular-redux/README.md
index 94c5415..3e0b3a3 100644
--- a/projects/angular-redux/README.md
+++ b/projects/angular-redux/README.md
@@ -5,6 +5,7 @@ Performant and flexible.
 
 ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/reduxjs/angular-redux/test.yml?style=flat-square) [![npm version](https://img.shields.io/npm/v/@reduxjs/angular-redux.svg?style=flat-square)](https://www.npmjs.com/package/@reduxjs/angular-redux)
 [![npm downloads](https://img.shields.io/npm/dm/@reduxjs/angular-redux.svg?style=flat-square)](https://www.npmjs.com/package/@reduxjs/angular-redux)
+[![#redux channel on Discord](https://img.shields.io/badge/discord-redux@reactiflux-61DAFB.svg?style=flat-square)](http://www.reactiflux.com)
 
 ## Installation
 
@@ -48,34 +49,10 @@ yarn add @reduxjs/angular-redux
 
 You'll also need to [install Redux](https://redux.js.org/introduction/installation) and [set up a Redux store](https://redux.js.org/recipes/configuring-your-store/) in your app.
 
-This assumes that you’re using [npm](http://npmjs.com/) package manager
-with a module bundler like [Webpack](https://webpack.js.org/) or
-[Browserify](http://browserify.org/) to consume [CommonJS
-modules](https://webpack.js.org/api/module-methods/#commonjs).
-
-# Usage
-
-The following Angular component works as-expected:
-
-```typescript
-import { Component } from "@angular/core";
-import { injectSelector, injectDispatch } from "@reduxjs/angular-redux";
-import { decrement, increment } from "./store/counter-slice";
-import { RootState } from "./store";
-
-@Component({
-  selector: "app-root",
-  standalone: true,
-  template: `
-    <button (click)="dispatch(increment())">Increment</button>
-    <span>{{ count() }}</span>
-    <button (click)="dispatch(decrement())">Decrement</button>
-  `,
-})
-export class AppComponent {
-  count = injectSelector((state: RootState) => state.counter.value);
-  dispatch = injectDispatch();
-  increment = increment;
-  decrement = decrement;
-}
-```
+## Documentation
+
+The React Redux docs are published at **https://angular-redux.js.org** .
+
+## License
+
+[MIT](LICENSE.md)

From f6128b3640be03567c11cc3a0af5147292151740 Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Sun, 15 Sep 2024 02:07:43 -0700
Subject: [PATCH 6/7] docs: update code embed to Angular example

---
 docs/tutorials/quick-start.md                 | 21 ++++++++++++-------
 .../angular-redux-demo/src/app/store/index.ts |  2 +-
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/docs/tutorials/quick-start.md b/docs/tutorials/quick-start.md
index 7d3a529..d4b9aa4 100644
--- a/docs/tutorials/quick-start.md
+++ b/docs/tutorials/quick-start.md
@@ -79,13 +79,13 @@ bootstrapApplication(AppComponent, {
 
 ### Create a Redux State Slice
 
-Add a new file named `src/features/counter/counterSlice.ts`. In that file, import the `createSlice` API from Redux Toolkit.
+Add a new file named `src/features/counter/counter-slice.ts`. In that file, import the `createSlice` API from Redux Toolkit.
 
 Creating a slice requires a string name to identify the slice, an initial state value, and one or more reducer functions to define how the state can be updated. Once a slice is created, we can export the generated Redux action creators and the reducer function for the whole slice.
 
 Redux requires that [we write all state updates immutably, by making copies of data and updating the copies](https://redux.js.org/tutorials/fundamentals/part-2-concepts-data-flow#immutability). However, Redux Toolkit's `createSlice` and `createReducer` APIs use [Immer](https://immerjs.github.io/immer/) inside to allow us to [write "mutating" update logic that becomes correct immutable updates](https://redux.js.org/tutorials/fundamentals/part-8-modern-redux#immutable-updates-with-immer).
 
-```js title="features/counter/counterSlice.ts"
+```js title="features/counter/counter-slice.ts"
 import { createSlice } from "@reduxjs/toolkit";
 
 export const counterSlice = createSlice({
@@ -124,7 +124,12 @@ Next, we need to import the reducer function from the counter slice and add it t
 ```js title="app/store.ts"
 import { configureStore } from "@reduxjs/toolkit";
 // highlight-next-line
-import counterReducer from "../features/counter/counterSlice";
+import counterReducer from "./features/counter/counter-slice";
+
+// Infer the `RootState` and `AppDispatch` types from the store itself
+export type RootState = ReturnType<typeof store.getState>;
+// Inferred type: {counter: CounterState}
+export type AppDispatch = typeof store.dispatch;
 
 export default configureStore({
   reducer: {
@@ -141,8 +146,8 @@ Now we can use the Angular Redux inject functions to let Angular components inte
 ```typescript title="features/counter/counter.component.ts"
 import { Component } from "@angular/core";
 import { injectSelector, injectDispatch } from "@reduxjs/angular-redux";
-import { decrement, increment } from "./store/counter-slice";
-import { RootState } from "./store";
+import { RootState } from "../../store";
+import { decrement, increment } from "./counter-slice";
 
 @Component({
   selector: "app-counter",
@@ -191,12 +196,12 @@ That was a brief overview of how to set up and use Redux Toolkit with Angular. R
 
 ### Full Counter App Example
 
-Here's the complete Counter application as a running CodeSandbox:
+Here's the complete Counter application as a running StackBlitz:
 
 <iframe
   class="codesandbox"
-  src="https://codesandbox.io/embed/github/reduxjs/redux-essentials-counter-example/tree/master/?fontsize=14&hidenavigation=1&module=%2Fsrc%2Ffeatures%2Fcounter%2FcounterSlice.js&theme=dark&runonclick=1"
-  title="redux-essentials-example"
+  src="https://stackblitz.com/github/reduxjs/angular-redux-essentials-counter-example/tree/main?template=node&ctl=1&embed=1&file=src%2Fapp%2Ffeatures%2Fcounter%2Fcounter-slice.ts&hideNavigation=1&view=preview"
+  title="angular-redux-essentials-example"
   allow="geolocation; microphone; camera; midi; vr; accelerometer; gyroscope; payment; ambient-light-sensor; encrypted-media; usb"
   sandbox="allow-modals allow-forms allow-popups allow-scripts allow-same-origin"
 ></iframe>
diff --git a/projects/angular-redux-demo/src/app/store/index.ts b/projects/angular-redux-demo/src/app/store/index.ts
index 1f0c5e6..0e410ac 100644
--- a/projects/angular-redux-demo/src/app/store/index.ts
+++ b/projects/angular-redux-demo/src/app/store/index.ts
@@ -9,5 +9,5 @@ export const store = configureStore({
 
 // Infer the `RootState` and `AppDispatch` types from the store itself
 export type RootState = ReturnType<typeof store.getState>;
-// Inferred type: {posts: PostsState, comments: CommentsState, users: UsersState}
+// Inferred type: {counter: CounterState}
 export type AppDispatch = typeof store.dispatch;

From 4ef306ba291e95159f106106183306f4c7b5d498 Mon Sep 17 00:00:00 2001
From: Corbin Crutchley <git@crutchcorn.dev>
Date: Sun, 15 Sep 2024 03:16:48 -0700
Subject: [PATCH 7/7] release: version 1.0.0

---
 projects/angular-redux/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/projects/angular-redux/package.json b/projects/angular-redux/package.json
index 5ca3c64..8584196 100644
--- a/projects/angular-redux/package.json
+++ b/projects/angular-redux/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@reduxjs/angular-redux",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "keywords": [
     "angular",
     "redux"
